celluloid 0.15.2 → 0.16.0

data/spec/celluloid/cpu_counter_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Celluloid::CPUCounter do
+  describe :cores do
+    subject { described_class.cores }
+
+    let(:num_cores) { 1024 }
+
+    before do
+      described_class.stub(:`) { fail 'backtick stub called' }
+      ::IO.stub(:open).and_raise('IO.open stub called!')
+      described_class.instance_variable_set('@cores', nil)
+    end
+
+    after { ENV['NUMBER_OF_PROCESSORS'] = nil }
+
+    context 'from valid env value' do
+      before { ENV['NUMBER_OF_PROCESSORS'] = num_cores.to_s }
+      it { should eq num_cores }
+    end
+
+    context 'from invalid env value' do
+      before { ENV['NUMBER_OF_PROCESSORS'] = '' }
+      specify { expect { subject }.to raise_error(ArgumentError) }
+    end
+
+    context 'with no env value' do
+      before { ENV['NUMBER_OF_PROCESSORS'] = nil }
+
+      context 'when /sys/devices/system/cpu/present exists' do
+        before do
+          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
+            .and_return("dunno-whatever-#{num_cores - 1}")
+        end
+        it { should eq num_cores }
+      end
+
+      context 'when /sys/devices/system/cpu/present does NOT exist' do
+        before do
+          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
+            .and_raise(Errno::ENOENT)
+        end
+
+        context 'when /sys/devices/system/cpu/cpu* files exist' do
+          before do
+            cpu_entries = (1..num_cores).map { |n| "cpu#{n}" }
+            cpu_entries << 'non-cpu-entry-to-ignore'
+            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
+              .and_return(cpu_entries)
+          end
+          it { should eq num_cores }
+        end
+
+        context 'when /sys/devices/system/cpu/cpu* files DO NOT exist' do
+          before do
+            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
+              .and_return([])
+          end
+
+          context 'when sysctl blows up' do
+            before { described_class.stub(:`).and_raise(Errno::EINTR) }
+            specify { expect { subject }.to raise_error }
+          end
+
+          context 'when sysctl fails' do
+            before { described_class.stub(:`).and_return(`false`) }
+            it { should be nil }
+          end
+
+          context 'when sysctl succeeds' do
+            before do
+              described_class.should_receive(:`).with('sysctl -n hw.ncpu')
+                .and_return(num_cores.to_s)
+              `true`
+            end
+            it { should eq num_cores }
+          end
+        end
+      end
+    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
@@ -14,11 +14,23 @@ describe "Celluloid.pool" do
       end
     end
 
+    def sleepy_work
+      t = Time.now.to_f
+      sleep 0.25
+      t
+    end
+
     def crash
       raise ExampleError, "zomgcrash"
     end
   end
 
+  def test_concurrency_of(pool)
+    baseline = Time.now.to_f
+    values = 10.times.map { pool.future.sleepy_work }.map(&:value)
+    values.select {|t| t - baseline < 0.1 }.length
+  end
+
   subject { MyWorker.pool }
 
   it "processes work units synchronously" do
@@ -56,4 +68,25 @@ describe "Celluloid.pool" do
     end
     futures.map(&:value)
   end
+
+  context "#size=" do
+    subject { MyWorker.pool size: 4 }
+
+    it "should adjust the pool size up", pending: 'flaky' do
+      expect(test_concurrency_of(subject)).to eq(4)
+
+      subject.size = 6
+      subject.size.should == 6
+
+      test_concurrency_of(subject).should == 6
+    end
+
+    it "should adjust the pool size down" do
+      test_concurrency_of(subject).should == 4
+
+      subject.size = 2
+      subject.size.should == 2
+      test_concurrency_of(subject).should == 2
+    end
+  end
 end

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

data/spec/celluloid/registry_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Registry do
+describe Celluloid::Registry, actor_system: :global do
   class Marilyn
     include Celluloid
 
@@ -27,21 +27,21 @@ describe Celluloid::Registry do
 
   it "knows its name once registered" do
     Celluloid::Actor[:marilyn] = Marilyn.new
-    Celluloid::Actor[:marilyn].name.should == :marilyn
+    Celluloid::Actor[:marilyn].registered_name.should == :marilyn
   end
 
   describe :delete do
     before do
       Celluloid::Actor[:marilyn] ||= Marilyn.new
     end
-    
+
     it "removes reference to actors' name from the registry" do
-      Celluloid::Registry.root.delete(:marilyn)
+      Celluloid::Actor.delete(:marilyn)
       Celluloid::Actor.registered.should_not include :marilyn
     end
-    
+
     it "returns actor removed from the registry" do
-      rval = Celluloid::Registry.root.delete(:marilyn)
+      rval = Celluloid::Actor.delete(:marilyn)
       rval.should be_kind_of(Marilyn)
     end
   end

data/spec/celluloid/stack_dump_spec.rb

@@ -1,6 +1,14 @@
 require 'spec_helper'
 
 describe Celluloid::StackDump do
+  let(:actor_system) do
+    Celluloid::ActorSystem.new
+  end
+
+  subject do
+    actor_system.stack_dump
+  end
+
   class BlockingActor
     include Celluloid
 
@@ -14,22 +22,43 @@ describe Celluloid::StackDump do
       actor_klass = Class.new(BlockingActor) do
         task_class task_klass
       end
-      actor = actor_klass.new
+      actor = actor_system.within do
+        actor_klass.new
+      end
       actor.async.blocking
     end
 
-    Celluloid.internal_pool.get do
-      Thread.current.role = :testing
+    @active_thread = actor_system.get_thread do
       sleep
     end
+    @active_thread.role = :other_thing
+    @idle_thread = actor_system.get_thread do
+    end
+
+    sleep 0.01
   end
 
-  it 'should include all actors' do
-    subject.actors.size.should == Celluloid::Actor.all.size
+  describe '#actors' do
+    it 'should include all actors' do
+      subject.actors.size.should == actor_system.running.size
+    end
   end
 
-  it 'should include threads that are not actors' do
-    pending "bugs"
-    subject.threads.size.should == 2
+  describe '#threads' do
+    it 'should include threads that are not actors', pending: 'flaky' do
+      expect(subject.threads.size).to eq(3)
+    end
+
+    it 'should include idle threads' do
+      subject.threads.map(&:thread_id).should include(@idle_thread.object_id)
+    end
+
+    it 'should include threads checked out of the pool for roles other than :actor' do
+      subject.threads.map(&:thread_id).should include(@active_thread.object_id)
+    end
+
+    it 'should have the correct roles', pending: 'flaky' do
+      expect(subject.threads.map(&:role)).to include(nil, :other_thing, :task)
+    end
   end
 end

data/spec/celluloid/supervision_group_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::SupervisionGroup do
+describe Celluloid::SupervisionGroup, actor_system: :global do
   before :all do
     class MyActor
       include Celluloid
@@ -55,5 +55,11 @@ describe Celluloid::SupervisionGroup do
       Celluloid::Actor[:example_pool].args.should eq ['foo']
       Celluloid::Actor[:example_pool].size.should be 3
     end
+
+    it "allows external access to the internal registry" do
+      supervisor = MyGroup.run!
+
+      supervisor[:example].should be_a MyActor
+    end
   end
 end

data/spec/celluloid/supervisor_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Supervisor do
+describe Celluloid::Supervisor, actor_system: :global do
   class SubordinateDead < StandardError; end
 
   class Subordinate
@@ -89,4 +89,15 @@ describe Celluloid::Supervisor do
     new_subordinate.should_not eq subordinate
     new_subordinate.state.should be(:working)
   end
+
+  it "removes an actor if it terminates cleanly" do
+    supervisor = Subordinate.supervise(:working)
+    subordinate = supervisor.actors.first
+
+    supervisor.actors.should == [subordinate]
+
+    subordinate.terminate
+
+    supervisor.actors.should be_empty
+  end
 end

data/spec/celluloid/tasks/task_fiber_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe Celluloid::TaskFiber do
+describe Celluloid::TaskFiber, actor_system: :within do
   it_behaves_like "a Celluloid Task", Celluloid::TaskFiber
 end

data/spec/celluloid/tasks/task_thread_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe Celluloid::TaskThread do
+describe Celluloid::TaskThread, actor_system: :within do
   it_behaves_like "a Celluloid Task", Celluloid::TaskThread
 end

data/spec/celluloid/thread_handle_spec.rb

@@ -1,9 +1,13 @@
 require 'spec_helper'
 
 describe Celluloid::ThreadHandle do
+  let(:actor_system) do
+    Celluloid::ActorSystem.new
+  end
+
   it "knows thread liveliness" do
     queue = Queue.new
-    handle = Celluloid::ThreadHandle.new { queue.pop }
+    handle = Celluloid::ThreadHandle.new(actor_system) { queue.pop }
     handle.should be_alive
 
     queue << :die
@@ -13,10 +17,10 @@ describe Celluloid::ThreadHandle do
   end
 
   it "joins to thread handles" do
-    Celluloid::ThreadHandle.new { sleep 0.01 }.join
+    Celluloid::ThreadHandle.new(actor_system) { sleep 0.01 }.join
   end
 
   it "supports passing a role" do
-    Celluloid::ThreadHandle.new(:useful) { Thread.current.role.should == :useful }.join
+    Celluloid::ThreadHandle.new(actor_system, :useful) { Thread.current.role.should == :useful }.join
   end
 end

data/spec/celluloid/timer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class EveryActor
+  include Celluloid
+
+  def initialize
+    @trace = []
+    @times = []
+    @start = Time.now
+    
+    every(1) { log(1) }
+    every(2) { log(2) }
+    every(1) { log(11) }
+    every(2) { log(22) }
+  end
+  
+  def log(t)
+    @trace << t
+    
+    offset = Time.now - @start
+    @times << offset
+    
+    # puts "log(#{t}) @ #{offset}"
+  end
+  
+  attr :trace
+  attr :times
+end
+
+describe Celluloid::Actor do
+  it "run every(t) task several times" do
+    Celluloid.boot
+    
+    every_actor = EveryActor.new
+    
+    sleep 5.5
+    
+    times = every_actor.times
+    trace = every_actor.trace
+    
+    Celluloid.shutdown
+    
+    expect(trace.count(1)).to be == 5
+    expect(trace.count(11)).to be == 5
+    expect(trace.count(2)).to be == 2
+    expect(trace.count(22)).to be == 2
+  end
+end

data/spec/spec_helper.rb

@@ -4,11 +4,12 @@ Coveralls.wear!
 require 'rubygems'
 require 'bundler/setup'
 require 'celluloid/rspec'
+require 'celluloid/probe'
 
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
 logfile.sync = true
 
-logger = Celluloid.logger = Logger.new(logfile)
+Celluloid.logger = Logger.new(logfile)
 
 Celluloid.shutdown_timeout = 1
 
@@ -18,14 +19,26 @@ RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 
-  config.before do
-    Celluloid.logger = logger
-    if Celluloid.running?
-      Celluloid.shutdown
-      sleep 0.01
-      Celluloid.internal_pool.assert_inactive
+  config.around do |ex|
+    Celluloid.actor_system = nil
+    Thread.list.each do |thread|
+      next if thread == Thread.current
+      thread.kill
     end
 
+    ex.run
+  end
+
+  config.around actor_system: :global do |ex|
     Celluloid.boot
+    ex.run
+    Celluloid.shutdown
+  end
+
+  config.around actor_system: :within do |ex|
+    Celluloid::ActorSystem.new.within do
+      ex.run
+    end
   end
+
 end