celluloid 0.14.1 → 0.15.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83a01356fe7e144f11c0ac9db25951850f53c9b4
-  data.tar.gz: 243e2915cef408cf97229f8ec0a512bfb2524fb8
+  metadata.gz: 802e81b987e2d65c9d7055c2160805612db65b50
+  data.tar.gz: 2a2c5eaf4c8afa92a8ee3c782ffb3e6556454061
 SHA512:
-  metadata.gz: 60e75d013b08ff7101ea6280b31bd5976ba097e821880e3d6d9b935580c8515d05d8619bc6a3df7be1d2733366d97b482a3668443e59c3c9e397bc6a14e46c75
-  data.tar.gz: 3e9fe0851276289183c6ca52e72bc545dc174831d325d78a9682f63087c4f54ff3b6f454babf4b091641a163235f953e02bbf656cfbdce4e093ec35df831e167
+  metadata.gz: 3bee45fcc9e099fcd5b61d605fa06293d9454402f65601ff789aac7c679e9f0d206a7f696a53d37fa3febeda10163dd5c2e4da1bc8dece2101bf1a3f949ca60e
+  data.tar.gz: c897040ce47e50088ee2c53ea8291733d2214cb127d3014558e366f8a1e58239ea232a9d7381671d99c64fcf6dca6e65b6f1d8b335a986a8779b97f875a163da

data/README.md

@@ -99,7 +99,9 @@ Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'celluloid'
+```ruby
+gem 'celluloid'
+```
 
 And then execute:
 
@@ -111,7 +113,9 @@ Or install it yourself as:
 
 Inside of your Ruby program, require Celluloid with:
 
-    require 'celluloid/autostart'
+```ruby
+require 'celluloid/autostart'
+```
 
 Supported Platforms
 -------------------

data/lib/celluloid.rb

@@ -3,7 +3,14 @@ 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.0.pre'
+  Error = Class.new StandardError
+
   extend self # expose all instance methods as singleton methods
 
   # Warning message added to Celluloid objects accessed outside their actors
@@ -18,6 +25,24 @@ module Celluloid
     def included(klass)
       klass.send :extend,  ClassMethods
       klass.send :include, InstanceMethods
+
+      klass.send :extend, Properties
+
+      klass.property :mailbox_class, :default => Celluloid::Mailbox
+      klass.property :proxy_class,   :default => Celluloid::ActorProxy
+      klass.property :task_class,    :default => Celluloid.task_class
+      klass.property :mailbox_size
+
+      klass.property :execute_block_on_receiver,
+        :default => [:after, :every, :receive],
+        :multi   => true
+
+      klass.property :finalizer
+      klass.property :exit_handler
+
+      klass.send(:define_singleton_method, :trap_exit) do |*args|
+        exit_handler(*args)
+      end
     end
 
     # Are we currently inside of an actor?
@@ -48,6 +73,18 @@ module Celluloid
     end
     alias_method :dump, :stack_dump
 
+    # Detect if a particular call is recursing through multiple actors
+    def detect_recursion
+      actor = Thread.current[:celluloid_actor]
+      return unless actor
+
+      task = Thread.current[:celluloid_task]
+      return unless task
+
+      chain_id = 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)
@@ -63,10 +100,18 @@ module Celluloid
       end
     end
 
+    def boot
+      init
+      start
+    end
+
+    def init
+      self.internal_pool = InternalPool.new
+    end
+
     # Launch default services
     # FIXME: We should set up the supervision hierarchy here
-    def boot
-      internal_pool.reset
+    def start
       Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
       Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
     end
@@ -90,11 +135,12 @@ module Celluloid
 
     # Shut down all running actors
     def shutdown
+      actors = Actor.all
+
       Timeout.timeout(shutdown_timeout) do
         internal_pool.shutdown
 
-        actors = Actor.all
-        Logger.debug "Terminating #{actors.size} actors..." if actors.size > 0
+        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
@@ -103,21 +149,31 @@ module Celluloid
         actors.each do |actor|
           begin
             actor.terminate!
-          rescue DeadActorError, MailboxError
+          rescue DeadActorError
           end
         end
 
         actors.each do |actor|
           begin
             Actor.join(actor)
-          rescue DeadActorError, MailboxError
+          rescue DeadActorError
           end
         end
-
-        Logger.debug "Shutdown completed cleanly"
       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
+    end
+
+    def version
+      VERSION
     end
   end
 
@@ -173,63 +229,6 @@ module Celluloid
       Actor.join(new(*args, &block))
     end
 
-    # Trap errors from actors we're linked to when they exit
-    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
-    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 = nil)
-      if klass
-        mailbox.class = klass
-      else
-        mailbox.class
-      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
-    def task_class(klass = nil)
-      if klass
-        @task_class = klass
-      elsif defined?(@task_class)
-        @task_class
-      elsif superclass.respond_to? :task_class
-        superclass.task_class
-      else
-        Celluloid.task_class
-      end
-    end
-
     # Mark methods as running exclusively
     def exclusive(*methods)
       if methods.empty?
@@ -240,55 +239,22 @@ module Celluloid
       end
     end
 
-    # Mark methods as running blocks on the receiver
-    def execute_block_on_receiver(*methods)
-      receiver_block_executions.merge methods.map(&:to_sym)
-    end
-
-    def receiver_block_executions
-      @receiver_block_executions ||= Set.new([:after, :every, :receive])
-    end
-
     # Configuration options for Actor#new
     def actor_options
       {
-        :mailbox           => mailbox.build,
+        :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 => receiver_block_executions
+        :receiver_block_executions => execute_block_on_receiver
       }
     end
 
     def ===(other)
       other.kind_of? self
     end
-
-    def mailbox
-      @mailbox_factory ||= MailboxFactory.new(self)
-    end
-
-    class MailboxFactory
-      attr_accessor :class, :max_size
-
-      def initialize(actor)
-        @actor    = actor
-        @class    = nil
-        @max_size = nil
-      end
-
-      def build
-        mailbox = mailbox_class.new
-        mailbox.max_size = @max_size
-        mailbox
-      end
-
-      private
-      def mailbox_class
-        @class || (@actor.superclass.respond_to?(:mailbox_class) && @actor.superclass.mailbox_class) || Celluloid::Mailbox
-      end
-    end
   end
 
   # These are methods we don't want added to the Celluloid singleton but to be
@@ -326,6 +292,8 @@ module Celluloid
     end
 
     def inspect
+      return "..." if Celluloid.detect_recursion
+
       str = "#<"
 
       if leaked?
@@ -363,7 +331,7 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:celluloid_actor].terminate
+    Thread.current[:celluloid_actor].proxy.terminate!
   end
 
   # Send a signal with the given name to all waiting methods
@@ -383,7 +351,7 @@ module Celluloid
 
   # Obtain the UUID of the current call chain
   def call_chain_id
-    Thread.current[:celluloid_chain_id]
+    CallChain.current_id
   end
 
   # Obtain the running tasks for this actor
@@ -446,16 +414,30 @@ module Celluloid
     end
   end
 
+  # Timeout on task suspension (eg Sync calls to other actors)
+  def timeout(duration)
+    bt = caller
+    task = Task.current
+    timer = after(duration) do
+      exception = Task::TimeoutError.new
+      exception.set_backtrace bt
+      task.resume exception
+    end
+    yield
+  ensure
+    timer.cancel if timer
+  end
+
   # Run given block in an exclusive mode: all synchronous calls block the whole
   # actor, not only current message processing.
   def exclusive(&block)
-    Thread.current[:celluloid_actor].exclusive(&block)
+    Thread.current[:celluloid_task].exclusive(&block)
   end
 
   # Are we currently exclusive
   def exclusive?
-    actor = Thread.current[:celluloid_actor]
-    actor && actor.exclusive?
+    task = Thread.current[:celluloid_task]
+    task && task.exclusive?
   end
 
   # Call a block after a given interval, returning a Celluloid::Timer object
@@ -488,9 +470,8 @@ module Celluloid
   end
 end
 
-require 'celluloid/version'
-
 require 'celluloid/calls'
+require 'celluloid/call_chain'
 require 'celluloid/condition'
 require 'celluloid/thread'
 require 'celluloid/core_ext'
@@ -503,6 +484,7 @@ require 'celluloid/logger'
 require 'celluloid/mailbox'
 require 'celluloid/evented_mailbox'
 require 'celluloid/method'
+require 'celluloid/properties'
 require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
@@ -510,6 +492,7 @@ 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'
 
@@ -535,3 +518,4 @@ Celluloid.task_class = Celluloid::TaskFiber
 Celluloid.logger     = Logger.new(STDERR)
 Celluloid.shutdown_timeout = 10
 Celluloid.register_shutdown
+Celluloid.init

data/lib/celluloid/actor.rb

@@ -2,16 +2,16 @@ require 'timers'
 
 module Celluloid
   # Don't do Actor-like things outside Actor scope
-  class NotActorError < StandardError; end
+  class NotActorError < Celluloid::Error; end
 
   # Trying to do something to a dead actor
-  class DeadActorError < StandardError; end
+  class DeadActorError < Celluloid::Error; end
 
   # A timeout occured before the given request could complete
-  class TimeoutError < StandardError; end
+  class TimeoutError < Celluloid::Error; end
 
   # The sender made an error, not the current actor
-  class AbortError < StandardError
+  class AbortError < Celluloid::Error
     attr_reader :cause
 
     def initialize(cause)
@@ -77,8 +77,8 @@ module Celluloid
       # Obtain all running actors in the system
       def all
         actors = []
-        Thread.list.each do |t|
-          next unless t.celluloid? && t.role == :actor
+        Celluloid.internal_pool.each do |t|
+          next unless t.role == :actor
           actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
         end
         actors
@@ -121,10 +121,7 @@ module Celluloid
       # Forcibly kill a given actor
       def kill(actor)
         actor.thread.kill
-        begin
-          actor.mailbox.shutdown
-        rescue DeadActorError
-        end
+        actor.mailbox.shutdown if actor.mailbox.alive?
       end
 
       # Wait for an actor to terminate
@@ -136,12 +133,15 @@ module Celluloid
 
     # Wrap the given subject with an Actor
     def initialize(subject, options = {})
-      @subject      = subject
-      @mailbox      = options[:mailbox] || Mailbox.new
+      @subject = subject
+
+      @mailbox          = options.fetch(:mailbox_class, Mailbox).new
+      @mailbox.max_size = options.fetch(:mailbox_size, nil)
+
+      @task_class   = options[:task_class] || Celluloid.task_class
       @exit_handler = options[:exit_handler]
       @exclusives   = options[:exclusive_methods]
       @receiver_block_executions = options[:receiver_block_executions]
-      @task_class   = options[:task_class] || Celluloid.task_class
 
       @tasks     = TaskSet.new
       @links     = Links.new
@@ -193,28 +193,9 @@ module Celluloid
       @running = false
     end
 
-    # Is this actor running in exclusive mode?
-    def exclusive?
-      @exclusive
-    end
-
-    # Execute a code block in exclusive mode.
-    def exclusive
-      if @exclusive
-        yield
-      else
-        begin
-          @exclusive = true
-          yield
-        ensure
-          @exclusive = false
-        end
-      end
-    end
-
     # Perform a linking request with another actor
     def linking_request(receiver, type)
-      exclusive do
+      Celluloid.exclusive do
         start_time = Time.now
         receiver.mailbox << LinkingRequest.new(Actor.current, type)
         system_events = []
@@ -245,7 +226,7 @@ module Celluloid
 
     # Send a signal with the given name to all waiting methods
     def signal(name, value = nil)
-      @signals.send name, value
+      @signals.broadcast name, value
     end
 
     # Wait for the given signal
@@ -314,15 +295,17 @@ module Celluloid
       when SystemEvent
         handle_system_event message
       when Call
-        task(:call, message.method) {
-          if @receiver_block_executions && meth = message.method
-            if meth == :__send__
-              meth = message.arguments.first
-            end
-            if @receiver_block_executions.include?(meth.to_sym)
-              message.execute_block_on_receiver
-            end
+        meth = message.method
+        if meth == :__send__
+          meth = message.arguments.first
+        end
+        if @receiver_block_executions && meth
+          if @receiver_block_executions.include?(meth.to_sym)
+            message.execute_block_on_receiver
           end
+        end
+
+        task(:call, :method_name => meth, :dangerous_suspend => meth == :initialize) {
           message.dispatch(@subject)
         }
       when BlockCall
@@ -330,7 +313,9 @@ module Celluloid
       when BlockResponse, Response
         message.dispatch
       else
-        @receivers.handle_message(message)
+        unless @receivers.handle_message(message)
+          Logger.debug "Discarded message (unhandled): #{message}"
+        end
       end
       message
     end
@@ -339,13 +324,13 @@ module Celluloid
     def handle_system_event(event)
       case event
       when ExitEvent
-        task(:exit_handler, @exit_handler) { handle_exit_event event }
+        task(:exit_handler, :method_name => @exit_handler) { handle_exit_event event }
       when LinkingRequest
         event.process(links)
       when NamingRequest
         @name = event.name
       when TerminationRequest
-        @running = false
+        terminate
       when SignalConditionRequest
         event.call
       end
@@ -382,17 +367,9 @@ module Celluloid
 
     # Run the user-defined finalizer, if one is set
     def run_finalizer
-      # 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, true)
-        task(:finalizer, :finalize) { @subject.__send__(finalizer) }
+        task(:finalizer, :method_name => finalizer, :dangerous_suspend => true) { @subject.__send__(finalizer) }
       end
     rescue => ex
       Logger.crash("#{@subject.class}#finalize crashed!", ex)
@@ -402,25 +379,26 @@ module Celluloid
     def cleanup(exit_event)
       @mailbox.shutdown
       @links.each do |actor|
-        begin
+        if actor.mailbox.alive?
           actor.mailbox << exit_event
-        rescue MailboxError
-          # We're exiting/crashing, they're dead. Give up :(
         end
       end
 
-      tasks.each { |task| task.terminate }
+      tasks.to_a.each { |task| task.terminate }
     rescue => ex
       Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
     end
 
     # Run a method inside a task unless it's exclusive
-    def task(task_type, method_name = nil, &block)
-      if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
-        exclusive { block.call }
-      else
-        @task_class.new(task_type, &block).resume
-      end
+    def task(task_type, meta = nil)
+      method_name = meta && meta.fetch(:method_name, nil)
+      @task_class.new(task_type, meta) {
+        if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
+          Celluloid.exclusive { yield }
+        else
+          yield
+        end
+      }.resume
     end
   end
 end