celluloid 0.12.0 → 0.13.0

data/lib/celluloid.rb

@@ -6,11 +6,14 @@ require 'set'
 module Celluloid
   extend self # expose all instance methods as singleton methods
 
-  SHUTDOWN_TIMEOUT = 120 # How long actors have to terminate
+  # Warning message added to Celluloid objects accessed outside their actors
+  BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
 
   class << self
-    attr_accessor :logger     # Thread-safe logger class
-    attr_accessor :task_class # Default task type to use
+    attr_accessor :internal_pool    # Internal thread pool
+    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 included(klass)
       klass.send :extend,  ClassMethods
@@ -19,7 +22,7 @@ module Celluloid
 
     # Are we currently inside of an actor?
     def actor?
-      !!Thread.current[:actor]
+      !!Thread.current[:celluloid_actor]
     end
 
     # Generate a Universally Unique Identifier
@@ -29,21 +32,44 @@ module Celluloid
 
     # Obtain the number of CPUs in the system
     def cores
-      CPUCounter.cores
+     CPUCounter.cores
     end
     alias_method :cpus, :cores
     alias_method :ncpus, :cores
 
+    # Perform a stack dump of all actors to the given output object
+    def stack_dump(output = STDERR)
+      Celluloid::StackDump.new.dump(output)
+    end
+    alias_method :dump, :stack_dump
+
     # Define an exception handler for actor crashes
     def exception_handler(&block)
       Logger.exception_handler(&block)
     end
 
+    def suspend(status, waiter)
+      task = Thread.current[:celluloid_task]
+      if task && !Celluloid.exclusive?
+        waiter.before_suspend(task) if waiter.respond_to?(:before_suspend)
+        Task.suspend(status)
+      else
+        waiter.wait
+      end
+    end
+
+    # Launch default services
+    # FIXME: We should set up the supervision hierarchy here
+    def boot
+      Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+      Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+    end
+
     # Shut down all running actors
     def shutdown
-      Timeout.timeout(SHUTDOWN_TIMEOUT) do
+      Timeout.timeout(shutdown_timeout) do
         actors = Actor.all
-        Logger.info "Terminating #{actors.size} actors..." if actors.size > 0
+        Logger.debug "Terminating #{actors.size} actors..." if actors.size > 0
 
         # Attempt to shut down the supervision tree, if available
         Supervisor.root.terminate if Supervisor.root
@@ -63,14 +89,13 @@ module Celluloid
           end
         end
 
-        Logger.info "Shutdown completed cleanly"
+        Logger.debug "Shutdown completed cleanly"
       end
+    rescue Timeout::Error => ex
+      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
     end
   end
 
-  # Terminate all actors at exit
-  at_exit { shutdown }
-
   # Class methods added to classes which include Celluloid
   module ClassMethods
     # Create a new actor
@@ -120,26 +145,55 @@ module Celluloid
 
     # Run an actor in the foreground
     def run(*args, &block)
-      new(*args, &block).join
+      Actor.join(new(*args, &block))
     end
 
     # Trap errors from actors we're linked to when they exit
-    def trap_exit(callback)
-      @exit_handler = callback.to_sym
+    def exit_handler(callback = nil)
+      if callback
+        @exit_handler = callback.to_sym
+      elsif defined?(@exit_handler)
+        @exit_handler
+      elsif superclass.respond_to? :exit_handler
+        superclass.exit_handler
+      end
     end
-
-    # Configure a custom mailbox factory
-    def use_mailbox(klass = nil, &block)
-      if block
-        @mailbox_factory = block
-      else
-        mailbox_class(klass)
+    alias_method :trap_exit, :exit_handler
+
+    # Define a callback to run when the actor is finalized.
+    def finalizer(callback = nil)
+      if callback
+        @finalizer = callback.to_sym
+      elsif defined?(@finalizer)
+        @finalizer
+      elsif superclass.respond_to? :finalizer
+        superclass.finalizer
       end
     end
 
     # Define the mailbox class for this class
-    def mailbox_class(klass)
-      @mailbox_factory = proc { klass.new }
+    def mailbox_class(klass = nil)
+      if klass
+        @mailbox_class = klass
+      elsif defined?(@mailbox_class)
+        @mailbox_class
+      elsif superclass.respond_to? :mailbox_class
+        superclass.mailbox_class
+      else
+        Celluloid::Mailbox
+      end
+    end
+    
+    def proxy_class(klass = nil)
+      if klass
+        @proxy_class = klass
+      elsif defined?(@proxy_class)
+        @proxy_class
+      elsif superclass.respond_to? :proxy_class
+        superclass.proxy_class
+      else
+        Celluloid::ActorProxy
+      end
     end
 
     # Define the default task type for this class
@@ -165,24 +219,20 @@ module Celluloid
       end
     end
 
-    # Create a mailbox for this actor
-    def mailbox_factory
-      if defined?(@mailbox_factory)
-        @mailbox_factory.call
-      elsif superclass.respond_to? :mailbox_factory
-        superclass.mailbox_factory
-      else
-        Mailbox.new
-      end
+    # Mark methods as running blocks on the receiver
+    def execute_block_on_receiver(*methods)
+      # A noop method in preparation
+      # See https://github.com/celluloid/celluloid/pull/55
     end
 
     # Configuration options for Actor#new
     def actor_options
       {
-        :mailbox           => mailbox_factory,
-        :exit_handler      => @exit_handler,
-        :exclusive_methods => @exclusive_methods,
-        :task_class        => task_class
+        :mailbox           => mailbox_class.new,
+        :proxy_class       => proxy_class,
+        :task_class        => task_class,
+        :exit_handler      => exit_handler,
+        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil
       }
     end
 
@@ -194,44 +244,45 @@ module Celluloid
   # These are methods we don't want added to the Celluloid singleton but to be
   # defined on all classes that use Celluloid
   module InstanceMethods
-    # Obtain the Ruby object the actor is wrapping. This should ONLY be used
-    # for a limited set of use cases like runtime metaprogramming. Interacting
-    # directly with the wrapped object foregoes any kind of thread safety that
+    # Obtain the bare Ruby object the actor is wrapping. This is useful for
+    # only a limited set of use cases like runtime metaprogramming. Interacting
+    # directly with the bare object foregoes any kind of thread safety that
     # Celluloid would ordinarily provide you, and the object is guaranteed to
     # be shared with at least the actor thread. Tread carefully.
-    def wrapped_object; self; end
+    #
+    # Bare objects can be identified via #inspect output:
+    #
+    #     >> actor
+    #      => #<Celluloid::Actor(Foo:0x3fefcb77c194)>
+    #     >> actor.bare_object
+    #      => #<WARNING: BARE CELLULOID OBJECT (Foo:0x3fefcb77c194)>
+    #
+    def bare_object; self; end
+    alias_method :wrapped_object, :bare_object
+
+    # Are we being invoked in a different thread from our owner?
+    def leaked?
+      @celluloid_owner != Thread.current[:celluloid_actor]
+    end
 
     def inspect
-      str = "#<Celluloid::Actor(#{self.class}:0x#{object_id.to_s(16)})"
-      ivars = instance_variables.map do |ivar|
-        "#{ivar}=#{instance_variable_get(ivar).inspect}"
+      str = "#<"
+
+      if leaked?
+        str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
+      else
+        str << "Celluloid::ActorProxy"
       end
 
-      str << " " << ivars.join(' ') unless ivars.empty?
-      str << ">"
-    end
-
-    # Process async calls via method_missing
-    def method_missing(meth, *args, &block)
-      # bang methods are async calls
-      if meth.to_s.match(/!$/)
-        unbanged_meth = meth.to_s.sub(/!$/, '')
-        args.unshift unbanged_meth
-
-        call = AsyncCall.new(:__send__, args, block)
-        begin
-          Thread.current[:actor].mailbox << call
-        rescue MailboxError
-          # Silently swallow asynchronous calls to dead actors. There's no way
-          # to reliably generate DeadActorErrors for async calls, so users of
-          # async calls should find other ways to deal with actors dying
-          # during an async call (i.e. linking/supervisors)
-        end
+      str << "(#{self.class}:0x#{object_id.to_s(16)})"
+      str << " " unless instance_variables.empty?
 
-        return
+      instance_variables.each do |ivar|
+        next if ivar == Celluloid::OWNER_IVAR
+        str << "#{ivar}=#{instance_variable_get(ivar).inspect} "
       end
 
-      super
+      str.sub!(/\s$/, '>')
     end
   end
 
@@ -240,11 +291,6 @@ module Celluloid
   # directly inside of all classes that include Celluloid
   #
 
-  # Is this actor alive?
-  def alive?
-    Thread.current[:actor].alive?
-  end
-
   # Raise an exception in caller context, but stay running
   def abort(cause)
     cause = case cause
@@ -257,17 +303,17 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:actor].terminate
+    Thread.current[:celluloid_actor].terminate
   end
 
   # Send a signal with the given name to all waiting methods
   def signal(name, value = nil)
-    Thread.current[:actor].signal name, value
+    Thread.current[:celluloid_actor].signal name, value
   end
 
   # Wait for the given signal
   def wait(name)
-    Thread.current[:actor].wait name
+    Thread.current[:celluloid_actor].wait name
   end
 
   # Obtain the current_actor
@@ -275,6 +321,11 @@ module Celluloid
     Actor.current
   end
 
+  # Obtain the UUID of the current call chain
+  def call_chain_id
+    Thread.current[:celluloid_chain_id]
+  end
+
   # Obtain the name of the current actor
   def name
     Actor.name
@@ -282,12 +333,12 @@ module Celluloid
 
   # Obtain the running tasks for this actor
   def tasks
-    Thread.current[:actor].tasks.to_a
+    Thread.current[:celluloid_actor].tasks.to_a
   end
 
   # Obtain the Celluloid::Links for this actor
   def links
-    Thread.current[:actor].links
+    Thread.current[:celluloid_actor].links
   end
 
   # Watch for exit events from another actor
@@ -322,7 +373,7 @@ module Celluloid
 
   # Receive an asynchronous message via the actor protocol
   def receive(timeout = nil, &block)
-    actor = Thread.current[:actor]
+    actor = Thread.current[:celluloid_actor]
     if actor
       actor.receive(timeout, &block)
     else
@@ -332,7 +383,7 @@ module Celluloid
 
   # Sleep letting the actor continue processing messages
   def sleep(interval)
-    actor = Thread.current[:actor]
+    actor = Thread.current[:celluloid_actor]
     if actor
       actor.sleep(interval)
     else
@@ -343,23 +394,23 @@ module Celluloid
   # Run given block in an exclusive mode: all synchronous calls block the whole
   # actor, not only current message processing.
   def exclusive(&block)
-    Thread.current[:actor].exclusive(&block)
+    Thread.current[:celluloid_actor].exclusive(&block)
   end
 
   # Are we currently exclusive
   def exclusive?
-    actor = Thread.current[:actor]
+    actor = Thread.current[:celluloid_actor]
     actor && actor.exclusive?
   end
 
   # Call a block after a given interval, returning a Celluloid::Timer object
   def after(interval, &block)
-    Thread.current[:actor].after(interval, &block)
+    Thread.current[:celluloid_actor].after(interval, &block)
   end
 
   # Call a block every given interval, returning a Celluloid::Timer object
   def every(interval, &block)
-    Thread.current[:actor].every(interval, &block)
+    Thread.current[:celluloid_actor].every(interval, &block)
   end
 
   # Perform a blocking or computationally intensive action inside an
@@ -374,18 +425,18 @@ module Celluloid
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
     if meth
-      Actor.async Thread.current[:actor].mailbox, meth, *args, &block
+      Actor.async Thread.current[:celluloid_actor].mailbox, meth, *args, &block
     else
-      Thread.current[:actor].proxy.async
+      Thread.current[:celluloid_actor].proxy.async
     end
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
     if meth
-      Actor.future Thread.current[:actor].mailbox, meth, *args, &block
+      Actor.future Thread.current[:celluloid_actor].mailbox, meth, *args, &block
     else
-      Thread.current[:actor].proxy.future
+      Thread.current[:celluloid_actor].proxy.future
     end
   end
 end
@@ -393,6 +444,7 @@ end
 require 'celluloid/version'
 
 require 'celluloid/calls'
+require 'celluloid/condition'
 require 'celluloid/core_ext'
 require 'celluloid/cpu_counter'
 require 'celluloid/fiber'
@@ -406,8 +458,9 @@ require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
 require 'celluloid/signals'
+require 'celluloid/stack_dump'
 require 'celluloid/system_events'
-require 'celluloid/task'
+require 'celluloid/tasks'
 require 'celluloid/thread_handle'
 require 'celluloid/uuid'
 
@@ -422,5 +475,11 @@ 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/boot'
+# Configure default systemwide settings
+Celluloid.task_class = Celluloid::TaskFiber
+Celluloid.logger     = Logger.new(STDERR)
+Celluloid.shutdown_timeout = 10