celluloid 0.12.4 → 0.13.0.pre

data/README.md

@@ -2,7 +2,7 @@
 =========
 [![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
 [![Dependency Status](https://gemnasium.com/celluloid/celluloid.png)](https://gemnasium.com/celluloid/celluloid)
-[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/celluloid/celluloid)
+[![Code Climate](https://codeclimate.com/github/celluloid/celluloid.png)](https://codeclimate.com/github/celluloid/celluloid)
 
 > "I thought of objects being like biological cells and/or individual
 > computers on a network, only able to communicate with messages"
@@ -45,7 +45,7 @@ features which make concurrent programming simple, easy, and fun:
   The central idea: have you tried turning it off and on again? Celluloid
   takes care of rebooting subcomponents of your application when they crash,
   whether it's a single actor, or large (potentially multi-tiered) groups of
-  actors that are all interdependent. This means rather that worrying about
+  actors that are all interdependent. This means rather than worrying about
   rescuing every last exception, you can just sit back, relax, and let parts
   of your program crash, knowing Celluloid will automatically reboot them in
   a clean state. Celluloid provides its own implementation of the core
@@ -141,5 +141,5 @@ Contributing to Celluloid
 License
 -------
 
-Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
+Copyright (c) 2013 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.

data/lib/celluloid.rb

@@ -2,20 +2,20 @@ require 'logger'
 require 'thread'
 require 'timeout'
 require 'set'
-require 'facter'
 
 module Celluloid
   extend self # expose all instance methods as singleton methods
 
   # How long actors have to terminate
-  SHUTDOWN_TIMEOUT = 120
+  SHUTDOWN_TIMEOUT = 10
 
   # 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
 
     def included(klass)
       klass.send :extend,  ClassMethods
@@ -24,7 +24,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
@@ -34,15 +34,14 @@ module Celluloid
 
     # Obtain the number of CPUs in the system
     def cores
-      core_count = Facter.fact(:processorcount).value
-      Integer(core_count)
+     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::StackDumper.dump(output)
+      Celluloid::StackDump.new.dump(output)
     end
     alias_method :dump, :stack_dump
 
@@ -77,19 +76,8 @@ module Celluloid
 
         Logger.debug "Shutdown completed cleanly"
       end
-    end
-  end
-
-  # Terminate all actors at exit
-  at_exit do
-    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)
-      shutdown
-      exit exit_status if exit_status
-    else
-      shutdown
+    rescue Timeout::Error => ex
+      Logger.error("Couldn't cleanly terminate all actors in #{SHUTDOWN_TIMEOUT} seconds!")
     end
   end
 
@@ -157,22 +145,40 @@ module Celluloid
     end
     alias_method :trap_exit, :exit_handler
 
-    # Configure a custom mailbox factory
-    def use_mailbox(klass = nil, &block)
-      if block
-        @mailbox_factory = block
-      else
-        mailbox_class(klass)
+    # 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)
-      @proxy_factory = proc { klass }
+    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
@@ -198,35 +204,14 @@ 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
-    end
-    
-    def proxy_factory
-      if defined?(@proxy_factory)
-        @proxy_factory.call
-      elsif superclass.respond_to?(:proxy_factory)
-        superclass.proxy_factory
-      else
-        nil
-      end
-    end
-
     # Configuration options for Actor#new
     def actor_options
       {
-        :mailbox           => mailbox_factory,
-        :proxy_class       => proxy_factory,
+        :mailbox           => mailbox_class.new,
+        :proxy_class       => proxy_class,
+        :task_class        => task_class,
         :exit_handler      => exit_handler,
-        :exclusive_methods => @exclusive_methods,
-        :task_class        => task_class
+        :exclusive_methods => @exclusive_methods
       }
     end
 
@@ -256,7 +241,7 @@ module Celluloid
 
     # Are we being invoked in a different thread from our owner?
     def leaked?
-      @celluloid_owner != Thread.current[:actor]
+      @celluloid_owner != Thread.current[:celluloid_actor]
     end
 
     def inspect
@@ -265,7 +250,7 @@ module Celluloid
       if leaked?
         str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
       else
-        str << "Celluloid::Actor"
+        str << "Celluloid::ActorProxy"
       end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
@@ -278,29 +263,6 @@ module Celluloid
 
       str.sub!(/\s$/, '>')
     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
-
-        return
-      end
-
-      super
-    end
   end
 
   #
@@ -320,17 +282,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
@@ -338,6 +300,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
@@ -345,12 +312,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
@@ -385,7 +352,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
@@ -395,7 +362,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
@@ -406,23 +373,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
@@ -437,18 +404,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
@@ -456,7 +423,9 @@ end
 require 'celluloid/version'
 
 require 'celluloid/calls'
+require 'celluloid/condition'
 require 'celluloid/core_ext'
+require 'celluloid/cpu_counter'
 require 'celluloid/fiber'
 require 'celluloid/fsm'
 require 'celluloid/internal_pool'
@@ -468,9 +437,9 @@ require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
 require 'celluloid/signals'
-require 'celluloid/stack_dumper'
+require 'celluloid/stack_dump'
 require 'celluloid/system_events'
-require 'celluloid/task'
+require 'celluloid/tasks'
 require 'celluloid/thread_handle'
 require 'celluloid/uuid'
 
@@ -487,4 +456,5 @@ require 'celluloid/supervisor'
 require 'celluloid/notifications'
 require 'celluloid/logging'
 
+require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
 require 'celluloid/boot'

data/lib/celluloid/actor.rb

@@ -44,14 +44,14 @@ module Celluloid
 
       # Obtain the current actor
       def current
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.proxy
       end
 
       # Obtain the name of the current actor
       def name
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.name
       end
@@ -66,7 +66,7 @@ module Celluloid
           raise DeadActorError, "attempted to call a dead actor"
         end
 
-        if Thread.current[:task] && !Celluloid.exclusive?
+        if Thread.current[:celluloid_task] && !Celluloid.exclusive?
           Task.suspend(:callwait).value
         else
           response = loop do
@@ -74,7 +74,7 @@ module Celluloid
               msg.respond_to?(:call) and msg.call == call
             end
             break message unless message.is_a?(SystemEvent)
-            Thread.current[:actor].handle_system_event(message)
+            Thread.current[:celluloid_actor].handle_system_event(message)
           end
 
           response.value
@@ -104,7 +104,7 @@ module Celluloid
       def all
         actors = []
         Thread.list.each do |t|
-          actor = t[:actor]
+          actor = t[:celluloid_actor]
           actors << actor.proxy if actor and actor.respond_to?(:proxy)
         end
         actors
@@ -113,25 +113,25 @@ module Celluloid
       # Watch for exit events from another actor
       def monitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:actor].linking_request(actor, :link)
+        Thread.current[:celluloid_actor].linking_request(actor, :link)
       end
 
       # Stop waiting for exit events from another actor
       def unmonitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:actor].linking_request(actor, :unlink)
+        Thread.current[:celluloid_actor].linking_request(actor, :unlink)
       end
 
       # Link to another actor
       def link(actor)
         monitor actor
-        Thread.current[:actor].links << actor
+        Thread.current[:celluloid_actor].links << actor
       end
 
       # Unlink from another actor
       def unlink(actor)
         unmonitor actor
-        Thread.current[:actor].links.delete actor
+        Thread.current[:celluloid_actor].links.delete actor
       end
 
       # Are we monitoring the given actor?
@@ -141,7 +141,7 @@ module Celluloid
 
       # Are we bidirectionally linked to the given actor?
       def linked_to?(actor)
-        monitoring?(actor) && Thread.current[:actor].links.include?(actor)
+        monitoring?(actor) && Thread.current[:celluloid_actor].links.include?(actor)
       end
 
       # Forcibly kill a given actor
@@ -164,7 +164,6 @@ module Celluloid
     def initialize(subject, options = {})
       @subject      = subject
       @mailbox      = options[:mailbox] || Mailbox.new
-      @proxy_class  = options[:proxy_class] || ActorProxy
       @exit_handler = options[:exit_handler]
       @exclusives   = options[:exclusive_methods]
       @task_class   = options[:task_class] || Celluloid.task_class
@@ -179,12 +178,12 @@ module Celluloid
       @name      = nil
 
       @thread = ThreadHandle.new do
-        Thread.current[:actor]   = self
-        Thread.current[:mailbox] = @mailbox
+        Thread.current[:celluloid_actor]   = self
+        Thread.current[:celluloid_mailbox] = @mailbox
         run
       end
 
-      @proxy = @proxy_class.new(self)
+      @proxy = (options[:proxy_class] || ActorProxy).new(self)
       @subject.instance_variable_set(OWNER_IVAR, self)
     end
 
@@ -238,13 +237,15 @@ module Celluloid
     def linking_request(receiver, type)
       exclusive do
         start_time = Time.now
-
         receiver.mailbox << LinkingRequest.new(Actor.current, type)
         system_events = []
+
         loop do
           wait_interval = start_time + LINKING_TIMEOUT - Time.now
           message = @mailbox.receive(wait_interval) do |msg|
-            msg.is_a?(LinkingResponse) && msg.actor == receiver && msg.type == type
+            msg.is_a?(LinkingResponse) &&
+            msg.actor.mailbox.address == receiver.mailbox.address &&
+            msg.type == type
           end
 
           case message
@@ -309,7 +310,7 @@ module Celluloid
 
     # Sleep for the given amount of time
     def sleep(interval)
-      task = Thread.current[:task]
+      task = Thread.current[:celluloid_task]
       if task && !Celluloid.exclusive?
         @timers.after(interval) { task.resume }
         Task.suspend :sleeping
@@ -344,6 +345,8 @@ module Celluloid
         @name = event.name
       when TerminationRequest
         @running = false
+      when SignalConditionRequest
+        event.call
       end
     end
 
@@ -372,14 +375,24 @@ module Celluloid
       run_finalizer
       cleanup exit_event
     ensure
-      Thread.current[:actor]   = nil
-      Thread.current[:mailbox] = nil
+      Thread.current[:celluloid_actor]   = nil
+      Thread.current[:celluloid_mailbox] = nil
     end
 
     # Run the user-defined finalizer, if one is set
     def run_finalizer
-      return unless @subject.respond_to? :finalize
-      task(:finalizer, :finalize) { @subject.finalize }
+      # FIXME: remove before Celluloid 1.0
+      if @subject.respond_to?(:finalize) && @subject.class.finalizer != :finalize
+        Logger.warn("DEPRECATION WARNING: #{@subject.class}#finalize is deprecated and will be removed in Celluloid 1.0. " +
+          "Define finalizers with '#{@subject.class}.finalizer :callback.'")
+
+        task(:finalizer, :finalize) { @subject.finalize }
+      end
+
+      finalizer = @subject.class.finalizer
+      if finalizer && @subject.respond_to?(finalizer)
+        task(:finalizer, :finalize) { @subject.__send__(finalizer) }
+      end
     rescue => ex
       Logger.crash("#{@subject.class}#finalize crashed!", ex)
     end
@@ -387,7 +400,14 @@ module Celluloid
     # Clean up after this actor
     def cleanup(exit_event)
       @mailbox.shutdown
-      @links.send_event exit_event
+      @links.each do |actor|
+        begin
+          actor.mailbox << exit_event
+        rescue MailboxError
+          # We're exiting/crashing, they're dead. Give up :(
+        end
+      end
+
       tasks.each { |task| task.terminate }
     rescue => ex
       Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)