celluloid 0.15.2 → 0.16.0.pre

data/lib/celluloid/supervision_group.rb

@@ -5,6 +5,7 @@ module Celluloid
     trap_exit :restart_actor
 
     class << self
+
       # Actors or sub-applications to be supervised
       def blocks
         @blocks ||= []
@@ -55,10 +56,12 @@ module Celluloid
       end
     end
 
+    finalizer :finalize
+
     # Start the group
     def initialize(registry = nil)
       @members = []
-      @registry = registry || Registry.root
+      @registry = registry || Celluloid.actor_system.registry
 
       yield current_actor if block_given?
     end
@@ -81,18 +84,15 @@ module Celluloid
     def add(klass, options)
       member = Member.new(@registry, klass, options)
       @members << member
-      member
+      member.actor
     end
 
     def actors
       @members.map(&:actor)
     end
 
-    finalizer :finalize
-
-    # Terminate the group
-    def finalize
-      @members.reverse_each(&:terminate)
+    def [](actor_name)
+      @registry[actor_name]
     end
 
     # Restart a crashed actor
@@ -102,7 +102,12 @@ module Celluloid
       end
       raise "a group member went missing. This shouldn't be!" unless member
 
-      member.restart(reason)
+      if reason
+        member.restart
+      else
+        member.cleanup
+        @members.delete(member)
+      end
     end
 
     # A member of the group
@@ -137,21 +142,28 @@ module Celluloid
         @registry[@name] = @actor if @name
       end
 
-      def restart(reason)
+      def restart
         @actor = nil
-        @registry.delete(@name) if @name
-
-        # Ignore supervisors that shut down cleanly
-        return unless reason
+        cleanup
 
         start
       end
 
       def terminate
-        @registry.delete(@name) if @name
+        cleanup
         @actor.terminate if @actor
       rescue DeadActorError
       end
+
+      def cleanup
+        @registry.delete(@name) if @name
+      end
+    end
+
+    private
+
+    def finalize
+      @members.reverse_each(&:terminate) if @members
     end
   end
 end

data/lib/celluloid/tasks.rb

@@ -74,14 +74,9 @@ module Celluloid
       @status = status
 
       if $CELLULOID_DEBUG && @dangerous_suspend
-        warning = "Dangerously suspending task: "
-        warning << [
-          "type=#{@type.inspect}",
-          "meta=#{@meta.inspect}",
-          "status=#{@status.inspect}"
-        ].join(", ")
-
-        Logger.warn [warning, *caller[2..8]].join("\n\t")
+        Logger.with_backtrace(caller[2...8]) do |logger|
+          logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        end
       end
 
       value = signal
@@ -118,7 +113,9 @@ module Celluloid
       raise "Cannot terminate an exclusive task" if exclusive?
 
       if running?
-        Celluloid.logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        Logger.with_backtrace(backtrace) do |logger|
+          logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        end
         exception = Task::TerminatedError.new("task was terminated")
         exception.set_backtrace(caller)
         resume exception

data/lib/celluloid/tasks/task_fiber.rb

@@ -6,10 +6,12 @@ module Celluloid
 
     def create
       queue = Thread.current[:celluloid_queue]
+      actor_system = Thread.current[:celluloid_actor_system]
       @fiber = Fiber.new do
         # FIXME: cannot use the writer as specs run inside normal Threads
         Thread.current[:celluloid_role] = :actor
         Thread.current[:celluloid_queue] = queue
+        Thread.current[:celluloid_actor_system] = actor_system
         yield
       end
     end
@@ -33,5 +35,9 @@ module Celluloid
     rescue FiberError
       # If we're getting this the task should already be dead
     end
+
+    def backtrace
+      "#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::TaskThread` if you need backtraces here."
+    end
   end
 end

data/lib/celluloid/tasks/task_thread.rb

@@ -12,7 +12,8 @@ module Celluloid
     end
 
     def create
-      @thread = Celluloid::ThreadHandle.new(:task) do
+      # TODO: move this to ActorSystem#get_thread (ThreadHandle inside InternalPool)
+      @thread = ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
         begin
           ex = @resume_queue.pop
           raise ex if ex.is_a?(Task::TerminatedError)

data/lib/celluloid/thread_handle.rb

@@ -3,11 +3,11 @@ module Celluloid
   # accidentally do things to threads which have been returned to the pool,
   # such as, say, killing them
   class ThreadHandle
-    def initialize(role = nil)
+    def initialize(actor_system, role = nil)
       @mutex = Mutex.new
       @join  = ConditionVariable.new
 
-      @thread = Celluloid.internal_pool.get do
+      @thread = actor_system.get_thread do
         Thread.current.role = role
         begin
           yield

data/spec/celluloid/actor_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe Celluloid do
+describe Celluloid, actor_system: :global do
   it_behaves_like "a Celluloid Actor", Celluloid
 end

data/spec/celluloid/actor_system_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Celluloid::ActorSystem do
+  class TestActor
+    include Celluloid
+  end
+
+  it "supports non-global ActorSystem" do
+    subject.within do
+      Celluloid.actor_system.should == subject
+    end
+  end
+
+  it "starts default actors" do
+    subject.start
+
+    subject.registered.should == [:notifications_fanout, :default_incident_reporter]
+  end
+
+  it "support getting threads" do
+    queue = Queue.new
+    thread = subject.get_thread do
+      Celluloid.actor_system.should == subject
+      queue << nil
+    end
+    queue.pop
+  end
+
+  it "allows a stack dump" do
+    subject.stack_dump.should be_a(Celluloid::StackDump)
+  end
+
+  it "returns named actors" do
+    subject.registered.should be_empty
+
+    subject.within do
+      TestActor.supervise_as :test
+    end
+
+    subject.registered.should == [:test]
+  end
+
+  it "returns running actors" do
+    subject.running.should be_empty
+
+    first = subject.within do
+      TestActor.new
+    end
+
+    second = subject.within do
+      TestActor.new
+    end
+
+    subject.running.should == [first, second]
+  end
+
+  it "shuts down" do
+    subject.shutdown
+
+    lambda { subject.get_thread }.
+      should raise_error("Thread pool is not running")
+  end
+
+  it "warns nicely when no actor system is started" do
+    lambda { TestActor.new }.
+      should raise_error("Celluloid is not yet started; use Celluloid.boot")
+  end
+
+end

data/spec/celluloid/block_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Blocks" do
+describe "Blocks", actor_system: :global do
   class MyBlockActor
     include Celluloid
 

data/spec/celluloid/calls_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::SyncCall do
+describe Celluloid::SyncCall, actor_system: :global do
   class CallExampleActor
     include Celluloid
 

data/spec/celluloid/condition_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Condition do
+describe Celluloid::Condition, actor_system: :global do
   class ConditionExample
     include Celluloid
 
@@ -17,10 +17,10 @@ describe Celluloid::Condition do
       condition.signal value
     end
 
-    def wait_for_condition
+    def wait_for_condition(timeout = nil)
       @waiting = true
       begin
-        value = @condition.wait
+        value = @condition.wait(timeout)
         @signaled_times += 1
       ensure
         @waiting = false
@@ -62,4 +62,15 @@ describe Celluloid::Condition do
     actor.async.signal_condition condition, :value
     condition.wait.should eq(:value)
   end
+
+  it "times out inside normal Threads" do
+    condition = Celluloid::Condition.new
+    lambda { condition.wait(1) }.
+      should raise_error(Celluloid::ConditionError)
+  end
+
+  it "times out inside Tasks" do
+    lambda { actor.wait_for_condition(1) }.
+      should raise_error(Celluloid::ConditionError)
+  end
 end

data/spec/celluloid/cpu_counter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Celluloid::CPUCounter do
+  describe :cores do
+    it 'should return an integer' do
+      Celluloid::CPUCounter.cores.should be_kind_of(Fixnum)
+    end
+  end
+end

data/spec/celluloid/fsm_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::FSM do
+describe Celluloid::FSM, actor_system: :global do
   before :all do
     class TestMachine
       include Celluloid::FSM

data/spec/celluloid/future_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Future do
+describe Celluloid::Future, actor_system: :global do
   it "creates future objects that can be retrieved later" do
     future = Celluloid::Future.new { 40 + 2 }
     future.value.should == 42

data/spec/celluloid/notifications_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Notifications do
+describe Celluloid::Notifications, actor_system: :global do
   class Admirer
     include Celluloid
     include Celluloid::Notifications

data/spec/celluloid/pool_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Celluloid.pool" do
+describe "Celluloid.pool", actor_system: :global do
   class ExampleError < StandardError; end
 
   class MyWorker

data/spec/celluloid/probe_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+class DummyActor; include Celluloid; end
+
+class TestProbeClient
+  include Celluloid
+  include Celluloid::Notifications
+
+  attr_reader :buffer
+
+  def initialize()
+    @condition = Condition.new
+    subscribe(/celluloid\.events\..+/, :event_received)
+    @buffer = []
+  end
+
+  def wait
+    @condition.wait
+  end
+
+  def wait_event(topic, expected_actor1 = nil, expected_actor2 = nil)
+    loop do
+      wait
+      while ev = @buffer.shift()
+        if (ev[0] == topic) && (ev[1].mailbox.address == expected_actor1.mailbox.address) &&
+          (expected_actor2.nil? || (ev[2].mailbox.address == expected_actor2.mailbox.address) )
+          return ev
+        end
+      end
+    end
+  end
+
+  def event_received(topic, args)
+    @buffer << [topic, args[0], args[1]]
+    @condition.signal
+  end
+end
+
+describe "Probe", actor_system: :global do
+  describe 'on boot' do
+    it 'should capture system actor spawn' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      create_events = []
+      received_named_events = {
+        :default_incident_reporter => nil,
+        :notifications_fanout      => nil
+      }
+      # wait for the events we seek
+      Timeout.timeout(5) do
+        loop do
+          client.wait
+          while ev = client.buffer.shift
+            if ev[0] == 'celluloid.events.actor_created'
+              create_events << ev
+            elsif ev[0] == 'celluloid.events.actor_named'
+              if received_named_events.keys.include?(ev[1].name)
+                received_named_events[ev[1].name] = ev[1].mailbox.address
+              end
+            end
+          end
+          if received_named_events.all?{|_, v| v != nil }
+            break
+          end
+        end
+      end
+      received_named_events.all?{|_, v| v != nil }.should == true
+      # now check we got the create events for every actors
+      received_named_events.each do |_, mailbox_address|
+        found = create_events.detect{|_, aa| aa.mailbox.address == mailbox_address }
+        found.should_not == nil
+      end
+    end
+  end
+
+  describe 'after boot' do
+    it 'should send a notification when an actor is spawned' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actor_created', a)
+      end
+      event.should_not == nil
+    end
+
+    it 'should send a notification when an actor is named' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      Celluloid::Actor['a name'] = a
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actor_named', a)
+      end
+      event.should_not == nil
+    end
+
+    it 'should send a notification when actor dies' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      a.terminate
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actor_died', a)
+      end
+      event.should_not == nil
+    end
+
+    it 'should send a notification when actors are linked' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      b = DummyActor.new
+      a.link(b)
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actors_linked', a, b)
+      end
+      event.should_not == nil
+    end
+  end
+end