celluloid 0.15.2 → 0.16.0.pre3

data/lib/celluloid.rb

@@ -3,25 +3,32 @@ require 'thread'
 require 'timeout'
 require 'set'
 
-if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
-  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
-end
-
 module Celluloid
-  VERSION = '0.15.2'
-  Error = Class.new StandardError
+  # Expose all instance methods as singleton methods
+  extend self
+
+  VERSION = '0.16.0.pre3'
 
-  extend self # expose all instance methods as singleton methods
+  # Linking times out after 5 seconds
+  LINKING_TIMEOUT = 5
 
   # Warning message added to Celluloid objects accessed outside their actors
   BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
 
   class << self
-    attr_accessor :internal_pool    # Internal thread pool
+    attr_writer   :actor_system     # Default Actor System
     attr_accessor :logger           # Thread-safe logger class
     attr_accessor :task_class       # Default task type to use
     attr_accessor :shutdown_timeout # How long actors have to terminate
 
+    def actor_system
+      if Thread.current.celluloid?
+        Thread.current[:celluloid_actor_system] or raise Error, "actor system not running"
+      else
+        Thread.current[:celluloid_actor_system] || @actor_system or raise Error, "Celluloid is not yet started; use Celluloid.boot"
+      end
+    end
+
     def included(klass)
       klass.send :extend,  ClassMethods
       klass.send :include, InstanceMethods
@@ -29,19 +36,29 @@ module Celluloid
       klass.send :extend, Properties
 
       klass.property :mailbox_class, :default => Celluloid::Mailbox
-      klass.property :proxy_class,   :default => Celluloid::ActorProxy
+      klass.property :proxy_class,   :default => Celluloid::CellProxy
       klass.property :task_class,    :default => Celluloid.task_class
       klass.property :mailbox_size
 
+      klass.property :exclusive_actor, :default => false
+      klass.property :exclusive_methods, :multi => true
       klass.property :execute_block_on_receiver,
         :default => [:after, :every, :receive],
         :multi   => true
 
       klass.property :finalizer
-      klass.property :exit_handler
+      klass.property :exit_handler_name
 
       klass.send(:define_singleton_method, :trap_exit) do |*args|
-        exit_handler(*args)
+        exit_handler_name(*args)
+      end
+
+      klass.send(:define_singleton_method, :exclusive) do |*args|
+        if args.any?
+          exclusive_methods(*exclusive_methods, *args)
+        else
+          exclusive_actor true
+        end
       end
     end
 
@@ -69,7 +86,7 @@ module Celluloid
 
     # Perform a stack dump of all actors to the given output object
     def stack_dump(output = STDERR)
-      Celluloid::StackDump.new.dump(output)
+      actor_system.stack_dump.print(output)
     end
     alias_method :dump, :stack_dump
 
@@ -106,18 +123,15 @@ module Celluloid
     end
 
     def init
-      self.internal_pool = InternalPool.new
+      @actor_system = ActorSystem.new
     end
 
-    # Launch default services
-    # FIXME: We should set up the supervision hierarchy here
     def start
-      Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
-      Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+      actor_system.start
     end
 
     def running?
-      internal_pool
+      actor_system && actor_system.running?
     end
 
     def register_shutdown
@@ -139,41 +153,7 @@ module Celluloid
 
     # Shut down all running actors
     def shutdown
-      actors = Actor.all
-
-      Timeout.timeout(shutdown_timeout) do
-        internal_pool.shutdown
-
-        Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
-
-        # Attempt to shut down the supervision tree, if available
-        Supervisor.root.terminate if Supervisor.root
-
-        # Actors cannot self-terminate, you must do it for them
-        actors.each do |actor|
-          begin
-            actor.terminate!
-          rescue DeadActorError
-          end
-        end
-
-        actors.each do |actor|
-          begin
-            Actor.join(actor)
-          rescue DeadActorError
-          end
-        end
-      end
-    rescue Timeout::Error
-      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
-      actors.each do |actor|
-        begin
-          Actor.kill(actor)
-        rescue DeadActorError, MailboxDead
-        end
-      end
-    ensure
-      internal_pool.kill
+      actor_system.shutdown
     end
 
     def version
@@ -185,7 +165,7 @@ module Celluloid
   module ClassMethods
     # Create a new actor
     def new(*args, &block)
-      proxy = Actor.new(allocate, actor_options).proxy
+      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       proxy._send_(:initialize, *args, &block)
       proxy
     end
@@ -195,7 +175,7 @@ module Celluloid
     def new_link(*args, &block)
       raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
 
-      proxy = Actor.new(allocate, actor_options).proxy
+      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       Actor.link(proxy)
       proxy._send_(:initialize, *args, &block)
       proxy
@@ -233,26 +213,28 @@ module Celluloid
       Actor.join(new(*args, &block))
     end
 
-    # Mark methods as running exclusively
-    def exclusive(*methods)
-      if methods.empty?
-        @exclusive_methods = :all
-      elsif !defined?(@exclusive_methods) || @exclusive_methods != :all
-        @exclusive_methods ||= Set.new
-        @exclusive_methods.merge methods.map(&:to_sym)
-      end
+    def actor_system
+      Celluloid.actor_system
     end
 
     # Configuration options for Actor#new
     def actor_options
       {
+        :actor_system      => actor_system,
         :mailbox_class     => mailbox_class,
         :mailbox_size      => mailbox_size,
-        :proxy_class       => proxy_class,
         :task_class        => task_class,
-        :exit_handler      => exit_handler,
-        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil,
-        :receiver_block_executions => execute_block_on_receiver
+        :exclusive         => exclusive_actor,
+      }
+    end
+
+    def behavior_options
+      {
+        :proxy_class               => proxy_class,
+        :exclusive_methods         => exclusive_methods,
+        :exit_handler_name         => exit_handler_name,
+        :finalizer                 => finalizer,
+        :receiver_block_executions => execute_block_on_receiver,
       }
     end
 
@@ -291,9 +273,10 @@ module Celluloid
     end
 
     # Obtain the name of the current actor
-    def name
-      Actor.name
+    def registered_name
+      Actor.registered_name
     end
+    alias_method :name, :registered_name
 
     def inspect
       return "..." if Celluloid.detect_recursion
@@ -303,7 +286,7 @@ module Celluloid
       if leaked?
         str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
       else
-        str << "Celluloid::ActorProxy"
+        str << "Celluloid::CellProxy"
       end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
@@ -335,7 +318,7 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:celluloid_actor].proxy.terminate!
+    Thread.current[:celluloid_actor].behavior_proxy.terminate!
   end
 
   # Send a signal with the given name to all waiting methods
@@ -458,15 +441,21 @@ module Celluloid
 
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].proxy.async meth, *args, &block
+    Thread.current[:celluloid_actor].behavior_proxy.async meth, *args, &block
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].proxy.future meth, *args, &block
+    Thread.current[:celluloid_actor].behavior_proxy.future meth, *args, &block
   end
 end
 
+if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
+  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
+end
+
+require 'celluloid/exceptions'
+
 require 'celluloid/calls'
 require 'celluloid/call_chain'
 require 'celluloid/condition'
@@ -482,6 +471,7 @@ require 'celluloid/mailbox'
 require 'celluloid/evented_mailbox'
 require 'celluloid/method'
 require 'celluloid/properties'
+require 'celluloid/handlers'
 require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
@@ -495,13 +485,16 @@ require 'celluloid/uuid'
 
 require 'celluloid/proxies/abstract_proxy'
 require 'celluloid/proxies/sync_proxy'
+require 'celluloid/proxies/cell_proxy'
 require 'celluloid/proxies/actor_proxy'
 require 'celluloid/proxies/async_proxy'
 require 'celluloid/proxies/future_proxy'
 require 'celluloid/proxies/block_proxy'
 
 require 'celluloid/actor'
+require 'celluloid/cell'
 require 'celluloid/future'
+require 'celluloid/actor_system'
 require 'celluloid/pool_manager'
 require 'celluloid/supervision_group'
 require 'celluloid/supervisor'
@@ -510,6 +503,8 @@ require 'celluloid/logging'
 
 require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
 
+$CELLULOID_MONITORING = false
+
 # Configure default systemwide settings
 Celluloid.task_class = Celluloid::TaskFiber
 Celluloid.logger     = Logger.new(STDERR)

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,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