celluloid 0.16.0 → 0.17.3

data/lib/celluloid.rb

@@ -1,14 +1,22 @@
-require 'logger'
-require 'thread'
-require 'timeout'
-require 'set'
+require "logger"
+require "thread"
+require "timeout"
+require "set"
+
+$CELLULOID_DEBUG = false
+$CELLULOID_MANAGED ||= false
+
+require "celluloid/version"
+require "celluloid/notices"
+
+$CELLULOID_BACKPORTED = false if defined?(CELLULOID_FUTURE) && CELLULOID_FUTURE
+$CELLULOID_BACKPORTED = (ENV["CELLULOID_BACKPORTED"] != "false") unless defined?($CELLULOID_BACKPORTED)
+Celluloid::Notices.backported if $CELLULOID_BACKPORTED
 
 module Celluloid
   # Expose all instance methods as singleton methods
   extend self
 
-  VERSION = '0.16.0'
-
   # Linking times out after 5 seconds
   LINKING_TIMEOUT = 5
 
@@ -16,16 +24,18 @@ module Celluloid
   BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
 
   class << self
-    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
+    attr_writer :actor_system # Default Actor System
+    attr_accessor :logger               # Thread-safe logger class
+    attr_accessor :log_actor_crashes
+    attr_accessor :group_class          # Default internal thread group to use
+    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"
+        Thread.current[:celluloid_actor_system] || fail(Error, "actor system not running")
       else
-        Thread.current[:celluloid_actor_system] || @actor_system or raise Error, "Celluloid is not yet started; use Celluloid.boot"
+        Thread.current[:celluloid_actor_system] || @actor_system || fail(Error, "Celluloid is not yet started; use Celluloid.boot")
       end
     end
 
@@ -33,27 +43,32 @@ module Celluloid
       klass.send :extend,  ClassMethods
       klass.send :include, InstanceMethods
 
-      klass.send :extend, Properties
+      klass.send :extend, Internals::Properties
 
-      klass.property :mailbox_class, :default => Celluloid::Mailbox
-      klass.property :proxy_class,   :default => Celluloid::CellProxy
-      klass.property :task_class,    :default => Celluloid.task_class
+      klass.property :mailbox_class, default: Celluloid::Mailbox
+      klass.property :proxy_class,   default: Celluloid::Proxy::Cell
+      klass.property :task_class,    default: Celluloid.task_class
+      klass.property :group_class,   default: Celluloid.group_class
       klass.property :mailbox_size
 
-      klass.property :exclusive_actor, :default => false
-      klass.property :exclusive_methods, :multi => true
+      klass.property :exclusive_actor, default: false
+      klass.property :exclusive_methods, multi: true
       klass.property :execute_block_on_receiver,
-        :default => [:after, :every, :receive],
-        :multi   => true
+                     default: [:after, :every, :receive],
+                     multi: true
 
       klass.property :finalizer
       klass.property :exit_handler_name
 
-      klass.send(:define_singleton_method, :trap_exit) do |*args|
+      singleton = class << klass; self; end
+      singleton.send(:remove_method, :trap_exit) rescue nil
+      singleton.send(:remove_method, :exclusive) rescue nil
+
+      singleton.send(:define_method, :trap_exit) do |*args|
         exit_handler_name(*args)
       end
 
-      klass.send(:define_singleton_method, :exclusive) do |*args|
+      singleton.send(:define_method, :exclusive) do |*args|
         if args.any?
           exclusive_methods(*exclusive_methods, *args)
         else
@@ -74,12 +89,12 @@ module Celluloid
 
     # Generate a Universally Unique Identifier
     def uuid
-      UUID.generate
+      Internals::UUID.generate
     end
 
     # Obtain the number of CPUs in the system
     def cores
-     CPUCounter.cores
+      Internals::CPUCounter.cores
     end
     alias_method :cpus, :cores
     alias_method :ncpus, :cores
@@ -90,6 +105,16 @@ module Celluloid
     end
     alias_method :dump, :stack_dump
 
+    # Perform a stack summary of all actors to the given output object
+    def stack_summary(output = STDERR)
+      actor_system.stack_summary.print(output)
+    end
+    alias_method :summarize, :stack_summary
+
+    def public_registry
+      actor_system.public_registry
+    end
+
     # Detect if a particular call is recursing through multiple actors
     def detect_recursion
       actor = Thread.current[:celluloid_actor]
@@ -98,13 +123,13 @@ module Celluloid
       task = Thread.current[:celluloid_task]
       return unless task
 
-      chain_id = CallChain.current_id
+      chain_id = Internals::CallChain.current_id
       actor.tasks.to_a.any? { |t| t != task && t.chain_id == chain_id }
     end
 
     # Define an exception handler for actor crashes
     def exception_handler(&block)
-      Logger.exception_handler(&block)
+      Internals::Logger.exception_handler(&block)
     end
 
     def suspend(status, waiter)
@@ -123,7 +148,7 @@ module Celluloid
     end
 
     def init
-      @actor_system = ActorSystem.new
+      @actor_system = Actor::System.new
     end
 
     def start
@@ -135,13 +160,16 @@ module Celluloid
     end
 
     def register_shutdown
-      return if @shutdown_registered
+      return if defined?(@shutdown_registered) && @shutdown_registered
+
       # Terminate all actors at exit
       at_exit do
+        sleep 0.126 # hax grace period for unnaturally terminating actors
+        # allows "reason" in exit_handler to resolve before being destroyed
         if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
           # workaround for MRI bug losing exit status in at_exit block
           # http://bugs.ruby-lang.org/issues/5218
-          exit_status = $!.status if $!.is_a?(SystemExit)
+          exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
           Celluloid.shutdown
           exit exit_status if exit_status
         else
@@ -163,7 +191,6 @@ module Celluloid
 
   # Class methods added to classes which include Celluloid
   module ClassMethods
-    # Create a new actor
     def new(*args, &block)
       proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       proxy._send_(:initialize, *args, &block)
@@ -173,7 +200,7 @@ module Celluloid
 
     # Create a new actor and link to the current one
     def new_link(*args, &block)
-      raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
+      fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
 
       proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       Actor.link(proxy)
@@ -182,32 +209,6 @@ module Celluloid
     end
     alias_method :spawn_link, :new_link
 
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails
-    def supervise(*args, &block)
-      Supervisor.supervise(self, *args, &block)
-    end
-
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails, and keep the actor registered under a given name
-    def supervise_as(name, *args, &block)
-      Supervisor.supervise_as(name, self, *args, &block)
-    end
-
-    # Create a new pool of workers. Accepts the following options:
-    #
-    # * size: how many workers to create. Default is worker per CPU core
-    # * args: array of arguments to pass when creating a worker
-    #
-    def pool(options = {})
-      PoolManager.new(self, options)
-    end
-
-    # Same as pool, but links to the pool manager
-    def pool_link(options = {})
-      PoolManager.new_link(self, options)
-    end
-
     # Run an actor in the foreground
     def run(*args, &block)
       Actor.join(new(*args, &block))
@@ -220,26 +221,26 @@ module Celluloid
     # Configuration options for Actor#new
     def actor_options
       {
-        :actor_system      => actor_system,
-        :mailbox_class     => mailbox_class,
-        :mailbox_size      => mailbox_size,
-        :task_class        => task_class,
-        :exclusive         => exclusive_actor,
+        actor_system: actor_system,
+        mailbox_class: mailbox_class,
+        mailbox_size: mailbox_size,
+        task_class: task_class,
+        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,
+        proxy_class: proxy_class,
+        exclusive_methods: exclusive_methods,
+        exit_handler_name: exit_handler_name,
+        finalizer: finalizer,
+        receiver_block_executions: execute_block_on_receiver,
       }
     end
 
     def ===(other)
-      other.kind_of? self
+      other.is_a? self
     end
   end
 
@@ -259,7 +260,9 @@ module Celluloid
     #     >> actor.bare_object
     #      => #<WARNING: BARE CELLULOID OBJECT (Foo:0x3fefcb77c194)>
     #
-    def bare_object; self; end
+    def bare_object
+      self
+    end
     alias_method :wrapped_object, :bare_object
 
     # Are we being invoked in a different thread from our owner?
@@ -286,7 +289,7 @@ module Celluloid
       if leaked?
         str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
       else
-        str << "Celluloid::CellProxy"
+        str << "Celluloid::Proxy::Cell"
       end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
@@ -297,7 +300,11 @@ module Celluloid
         str << "#{ivar}=#{instance_variable_get(ivar).inspect} "
       end
 
-      str.sub!(/\s$/, '>')
+      str.sub!(/\s$/, ">")
+    end
+
+    def __arity
+      method(:initialize).arity
     end
   end
 
@@ -309,11 +316,11 @@ module Celluloid
   # Raise an exception in sender context, but stay running
   def abort(cause)
     cause = case cause
-      when String then RuntimeError.new(cause)
-      when Exception then cause
-      else raise TypeError, "Exception object/String expected, but #{cause.class} received"
+            when String then RuntimeError.new(cause)
+            when Exception then cause
+            else fail TypeError, "Exception object/String expected, but #{cause.class} received"
     end
-    raise AbortError.new(cause)
+    fail AbortError.new(cause)
   end
 
   # Terminate this actor
@@ -338,7 +345,7 @@ module Celluloid
 
   # Obtain the UUID of the current call chain
   def call_chain_id
-    CallChain.current_id
+    Internals::CallChain.current_id
   end
 
   # Obtain the running tasks for this actor
@@ -431,7 +438,7 @@ module Celluloid
   end
 
   # Perform a blocking or computationally intensive action inside an
-  # asynchronous thread pool, allowing the sender to continue processing other
+  # asynchronous group of threads, allowing the sender to continue processing other
   # messages in its mailbox in the meantime
   def defer(&block)
     # This implementation relies on the present implementation of
@@ -451,66 +458,80 @@ module Celluloid
 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+"
+  fail "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'
-require 'celluloid/thread'
-require 'celluloid/core_ext'
-require 'celluloid/cpu_counter'
-require 'celluloid/fiber'
-require 'celluloid/fsm'
-require 'celluloid/internal_pool'
-require 'celluloid/links'
-require 'celluloid/logger'
-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'
-require 'celluloid/signals'
-require 'celluloid/stack_dump'
-require 'celluloid/system_events'
-require 'celluloid/tasks'
-require 'celluloid/task_set'
-require 'celluloid/thread_handle'
-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'
-require 'celluloid/notifications'
-require 'celluloid/logging'
-
-require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
+require "celluloid/exceptions"
+
+Celluloid.logger = Logger.new(STDERR).tap do |logger|
+  logger.level = Logger::INFO unless $CELLULOID_DEBUG
+end
+
+Celluloid.shutdown_timeout = 10
+Celluloid.log_actor_crashes = true
+
+require "celluloid/calls"
+require "celluloid/condition"
+require "celluloid/thread"
+
+require "celluloid/core_ext"
+
+require "celluloid/system_events"
+
+require "celluloid/proxies"
+
+require "celluloid/mailbox"
+require "celluloid/mailbox/evented"
+
+require "celluloid/essentials"
+
+require "celluloid/group"
+require "celluloid/group/spawner"
+require "celluloid/group/pool"      # TODO: Find way to only load this if being used.
+
+require "celluloid/task"
+require "celluloid/task/fibered"
+require "celluloid/task/threaded"   # TODO: Find way to only load this if being used.
+
+require "celluloid/actor"
+require "celluloid/cell"
+require "celluloid/future"
+
+require "celluloid/actor/system"
+require "celluloid/actor/manager"
+
+require "celluloid/deprecate" unless $CELLULOID_BACKPORTED == false
 
 $CELLULOID_MONITORING = false
+Celluloid::Notices.output
 
 # Configure default systemwide settings
-Celluloid.task_class = Celluloid::TaskFiber
-Celluloid.logger     = Logger.new(STDERR)
-Celluloid.shutdown_timeout = 10
 
-unless $CELLULOID_TEST
+Celluloid.task_class =
+  begin
+    str = ENV["CELLULOID_TASK_CLASS"] || "Fibered"
+    Kernel.const_get(str)
+  rescue NameError
+    begin
+      Celluloid.const_get(str)
+    rescue NameError
+      Celluloid::Task.const_get(str)
+    end
+  end
+
+Celluloid.group_class =
+  begin
+    str = ENV["CELLULOID_GROUP_CLASS"] || "Spawner"
+    Kernel.const_get(str)
+  rescue NameError
+    begin
+      Celluloid.const_get(str)
+    rescue NameError
+      Celluloid::Group.const_get(str)
+    end
+  end
+
+unless defined?($CELLULOID_TEST) && $CELLULOID_TEST
   Celluloid.register_shutdown
   Celluloid.init
 end

data/spec/celluloid/actor/system_spec.rb

@@ -0,0 +1,83 @@
+RSpec.describe Celluloid::Actor::System do
+  class TestActor
+    include Celluloid
+    def identity
+      :testing
+    end
+  end
+
+  after do
+    subject.shutdown
+  end
+
+  it "supports non-global Actor::System" do
+    subject.within do
+      expect(Celluloid.actor_system).to eq(subject)
+    end
+  end
+
+  it "makes actors accessible by Celluloid[:actor]" do
+    subject.start
+    subject.within do
+      TestActor.supervise as: :testing, type: TestActor
+      expect(subject.registered).to include(:testing)
+      expect(Celluloid::Actor[:testing].identity).to eq(:testing)
+    end
+  end
+
+  it "starts default actors" do
+    subject.start
+    expect(subject.registered).to eq(Celluloid::Actor::System::ROOT_SERVICES.map { |r| r[:as] })
+  end
+
+  it "support getting threads" do
+    queue = Queue.new
+    subject.get_thread do
+      expect(Celluloid.actor_system).to eq(subject)
+      queue << nil
+    end
+    queue.pop
+  end
+
+  it "allows a stack dump" do
+    expect(subject.stack_dump).to be_a(Celluloid::Internals::Stack::Dump)
+  end
+
+  it "allows a stack summary" do
+    expect(subject.stack_summary).to be_a(Celluloid::Internals::Stack::Summary)
+  end
+
+  it "returns named actors" do
+    subject.start
+    subject.within do
+      TestActor.supervise as: :test
+    end
+    expect(subject.registered).to include(:test)
+  end
+
+  it "returns running actors" do
+    expect(subject.running).to be_empty
+
+    first = subject.within do
+      TestActor.new
+    end
+
+    second = subject.within do
+      TestActor.new
+    end
+
+    expect(subject.running).to eq([first, second])
+  end
+
+  it "shuts down" do
+    subject.shutdown
+
+    expect { subject.get_thread }
+      .to raise_error(Celluloid::NotActive)
+  end
+
+  it "warns nicely when no actor system is started" do
+    expect { TestActor.new }
+      .to raise_error("Celluloid is not yet started; use Celluloid.boot")
+  end
+end

data/spec/celluloid/actor_spec.rb

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

data/spec/celluloid/block_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe "Blocks", actor_system: :global do
+RSpec.describe "Blocks", actor_system: :global do
   class MyBlockActor
     include Celluloid
 
@@ -14,10 +12,36 @@ describe "Blocks", actor_system: :global do
       $data << [:outside, @name, current_actor.name]
       other.do_something_and_callback do |value|
         $data << [:yielded, @name, current_actor.name]
-        $data << self.receive_result(:self)
+        $data << receive_result(:self)
         $data << current_actor.receive_result(:current_actor)
         $data << sender_actor.receive_result(:sender)
-        "somevalue"
+        :pete_the_polyglot_alien
+      end
+    end
+
+    def deferred_excecution(value, &_block)
+      defer do
+        yield(value)
+      end
+    end
+
+    def deferred_current_actor(&_block)
+      defer do
+        yield(current_actor.name)
+      end
+    end
+
+    def defer_for_something(other, &_block)
+      sender_actor = current_actor
+      defer do
+        $data << [:outside, @name, current_actor.name]
+        other.do_something_and_callback do |value|
+          $data << [:yielded, @name, current_actor.name]
+          $data << receive_result(:self)
+          $data << current_actor.receive_result(:current_actor)
+          $data << sender_actor.receive_result(:sender)
+          :pete_the_polyglot_alien
+        end
       end
     end
 
@@ -31,7 +55,7 @@ describe "Blocks", actor_system: :global do
     end
   end
 
-  it "works" do
+  it "work between actors" do
     $data = []
 
     a1 = MyBlockActor.new("one")
@@ -46,9 +70,44 @@ describe "Blocks", actor_system: :global do
       [:self, "one", "one"],
       [:current_actor, "one", "one"],
       [:sender, "one", "one"],
-      "somevalue",
+      :pete_the_polyglot_alien,
+    ]
+
+    expect($data).to eq(expected)
+  end
+
+  execute_deferred = proc do
+    a1 = MyBlockActor.new("one")
+    expect(a1.deferred_excecution(:pete_the_polyglot_alien) { |v| v })
+    .to eq(:pete_the_polyglot_alien)
+  end
+
+  # unless RUBY_ENGINE == 'jruby'
+  xit("can be deferred", &execute_deferred)
+  # else
+  #   it("can be deferred", &execute_deferred)
+  # end
+
+  xit "can execute deferred blocks referencing current_actor" do
+    a1 = MyBlockActor.new("one")
+    expect(a1.deferred_current_actor { |v| v }).to be("one")
+  end
+
+  xit "can execute deferred blocks with another actor" do
+    $data = []
+    a1 = MyBlockActor.new("one")
+    a2 = MyBlockActor.new("two")
+    a1.defer_for_something a2
+    expected = [
+      [:outside, "one", "one"],
+      [:something, "two", "two"],
+      [:yielded, "one", "one"],
+      [:self, "one", "one"],
+      [:current_actor, "one", "one"],
+      [:sender, "one", "one"],
+      :pete_the_polyglot_alien,
     ]
 
-    $data.should eq(expected)
+    expect($data).to eq(expected)
   end
 end