celluloid 0.13.0 → 0.14.1

data/lib/celluloid/tasks/task_thread.rb

@@ -1,62 +1,38 @@
 module Celluloid
   # Tasks with a Thread backend
   class TaskThread < Task
-    attr_reader :type, :status
-
     # Run the given block within a task
     def initialize(type)
-      super
-
       @resume_queue = Queue.new
       @exception_queue = Queue.new
       @yield_mutex  = Mutex.new
       @yield_cond   = ConditionVariable.new
 
-      actor    = Thread.current[:celluloid_actor]
-      mailbox  = Thread.current[:celluloid_mailbox]
-      chain_id = Thread.current[:celluloid_chain_id]
-
-      raise NotActorError, "can't create tasks outside of actors" unless actor
+      super
+    end
 
+    def create
       @thread = Celluloid.internal_pool.get do
+        Thread.current.role = :task
         begin
           ex = @resume_queue.pop
           raise ex if ex.is_a?(Task::TerminatedError)
 
-          @status = :running
-          Thread.current[:celluloid_actor]    = actor
-          Thread.current[:celluloid_mailbox]  = mailbox
-          Thread.current[:celluloid_task]     = self
-          Thread.current[:celluloid_chain_id] = chain_id
-
-          actor.tasks << self
           yield
-        rescue Task::TerminatedError
-          # Task was explicitly terminated
         rescue Exception => ex
           @exception_queue << ex
         ensure
-          @status = :dead
-          actor.tasks.delete self
           @yield_cond.signal
         end
       end
     end
 
-    # Suspend the current task, changing the status to the given argument
-    def suspend(status)
-      @status = status
+    def signal
       @yield_cond.signal
-      value = @resume_queue.pop
-
-      raise value if value.is_a?(Task::TerminatedError)
-      @status = :running
-
-      value
+      @resume_queue.pop
     end
 
-    # Resume a suspended task, giving it a value to return if needed
-    def resume(value = nil)
+    def deliver(value)
       raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
 
       @yield_mutex.synchronize do
@@ -66,23 +42,12 @@ module Celluloid
           raise @exception_queue.pop
         end
       end
-
-      nil
     rescue ThreadError
       raise DeadTaskError, "cannot resume a dead task"
     end
 
-    # Terminate this task
-    def terminate
-      resume Task::TerminatedError.new("task was terminated") if @thread.alive?
-    end
-
-    # Is the current task still running?
-    def running?; @status != :dead; end
-
-    # Nicer string inspect for tasks
-    def inspect
-      "<Celluloid::TaskThread:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
+    def backtrace
+      @thread.backtrace
     end
   end
 end

data/lib/celluloid/tasks.rb

@@ -19,10 +19,71 @@ module Celluloid
       Task.current.suspend(status)
     end
 
+    attr_reader :type, :status
+
     # Create a new task
     def initialize(type)
       @type   = type
       @status = :new
+
+      actor    = Thread.current[:celluloid_actor]
+      chain_id = Thread.current[:celluloid_chain_id]
+
+      raise NotActorError, "can't create tasks outside of actors" unless actor
+
+      create do
+        begin
+          @status = :running
+          actor.setup_thread
+          Thread.current[:celluloid_task]     = self
+          Thread.current[:celluloid_chain_id] = chain_id
+
+          actor.tasks << self
+          yield
+        rescue Task::TerminatedError
+          # Task was explicitly terminated
+        ensure
+          @status = :dead
+          actor.tasks.delete self
+        end
+      end
+    end
+
+    def create(&block)
+      raise "Implement #{self.class}#create"
+    end
+
+    # Suspend the current task, changing the status to the given argument
+    def suspend(status)
+      @status = status
+      value = signal
+
+      raise value if value.is_a?(Task::TerminatedError)
+      @status = :running
+
+      value
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      deliver(value)
+      nil
+    end
+
+    # Terminate this task
+    def terminate
+      resume Task::TerminatedError.new("task was terminated") if running?
+    end
+
+    def backtrace
+    end
+
+    # Is the current task still running?
+    def running?; @status != :dead; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
     end
   end
   
@@ -42,7 +103,7 @@ module Celluloid
     end
   
     def each(&blk)
-      @tasks.each &blk
+      @tasks.each(&blk)
     end
   
     def first
@@ -56,4 +117,4 @@ module Celluloid
 end
 
 require 'celluloid/tasks/task_fiber'
-require 'celluloid/tasks/task_thread'
+require 'celluloid/tasks/task_thread'

data/lib/celluloid/thread.rb

@@ -0,0 +1,38 @@
+require 'celluloid/fiber'
+
+module Celluloid
+  class Thread < ::Thread
+    def celluloid?
+      true
+    end
+
+    # Obtain the role of this thread
+    def role
+      self[:celluloid_role]
+    end
+
+    def role=(role)
+      self[:celluloid_role] = role
+    end
+
+    # Obtain the Celluloid::Actor object for this thread
+    def actor
+      self[:celluloid_actor]
+    end
+
+    # Obtain the Celluloid task object for this thread
+    def task
+      self[:celluloid_task]
+    end
+
+    # Obtain the Celluloid mailbox for this thread
+    def mailbox
+      self[:celluloid_mailbox]
+    end
+
+    # Obtain the call chain ID for this thread
+    def call_chain_id
+      self[:celluloid_chain_id]
+    end
+  end
+end

data/lib/celluloid/thread_handle.rb

@@ -3,11 +3,12 @@ module Celluloid
   # accidentally do things to threads which have been returned to the pool,
   # such as, say, killing them
   class ThreadHandle
-    def initialize
+    def initialize(role = nil)
       @mutex = Mutex.new
       @join  = ConditionVariable.new
 
       @thread = Celluloid.internal_pool.get do
+        Thread.current.role = role
         begin
           yield
         ensure
@@ -31,8 +32,9 @@ module Celluloid
     end
 
     # Join to a running thread, blocking until it terminates
-    def join
-      @mutex.synchronize { @join.wait(@mutex) if @thread }
+    def join(limit = nil)
+      raise ThreadError, "Target thread must not be current thread" if @thread == Thread.current
+      @mutex.synchronize { @join.wait(@mutex, limit) if @thread }
       self
     end
 

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.13.0'
+  VERSION = '0.14.1'
   def self.version; VERSION; end
 end

data/lib/celluloid.rb

@@ -25,6 +25,11 @@ module Celluloid
       !!Thread.current[:celluloid_actor]
     end
 
+    # Retrieve the mailbox for the current thread or lazily initialize it
+    def mailbox
+      Thread.current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
+    end
+
     # Generate a Universally Unique Identifier
     def uuid
       UUID.generate
@@ -61,13 +66,33 @@ module Celluloid
     # Launch default services
     # FIXME: We should set up the supervision hierarchy here
     def boot
+      internal_pool.reset
       Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
       Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
     end
 
+    def register_shutdown
+      return if @shutdown_registered
+      # 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)
+          Celluloid.shutdown
+          exit exit_status if exit_status
+        else
+          Celluloid.shutdown
+        end
+      end
+      @shutdown_registered = true
+    end
+
     # Shut down all running actors
     def shutdown
       Timeout.timeout(shutdown_timeout) do
+        internal_pool.shutdown
+
         actors = Actor.all
         Logger.debug "Terminating #{actors.size} actors..." if actors.size > 0
 
@@ -75,14 +100,14 @@ module Celluloid
         Supervisor.root.terminate if Supervisor.root
 
         # Actors cannot self-terminate, you must do it for them
-        Actor.all.each do |actor|
+        actors.each do |actor|
           begin
             actor.terminate!
           rescue DeadActorError, MailboxError
           end
         end
 
-        Actor.all.each do |actor|
+        actors.each do |actor|
           begin
             Actor.join(actor)
           rescue DeadActorError, MailboxError
@@ -91,7 +116,7 @@ module Celluloid
 
         Logger.debug "Shutdown completed cleanly"
       end
-    rescue Timeout::Error => ex
+    rescue Timeout::Error
       Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
     end
   end
@@ -174,13 +199,9 @@ module Celluloid
     # Define the mailbox class for this class
     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
+        mailbox.class = klass
       else
-        Celluloid::Mailbox
+        mailbox.class
       end
     end
     
@@ -213,7 +234,7 @@ module Celluloid
     def exclusive(*methods)
       if methods.empty?
         @exclusive_methods = :all
-      elsif @exclusive_methods != :all
+      elsif !defined?(@exclusive_methods) || @exclusive_methods != :all
         @exclusive_methods ||= Set.new
         @exclusive_methods.merge methods.map(&:to_sym)
       end
@@ -221,24 +242,53 @@ module Celluloid
 
     # 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
+      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_class.new,
+        :mailbox           => mailbox.build,
         :proxy_class       => proxy_class,
         :task_class        => task_class,
         :exit_handler      => exit_handler,
-        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil
+        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil,
+        :receiver_block_executions => receiver_block_executions
       }
     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
@@ -265,6 +315,16 @@ module Celluloid
       @celluloid_owner != Thread.current[:celluloid_actor]
     end
 
+    def tap
+      yield current_actor
+      current_actor
+    end
+
+    # Obtain the name of the current actor
+    def name
+      Actor.name
+    end
+
     def inspect
       str = "#<"
 
@@ -291,7 +351,7 @@ module Celluloid
   # directly inside of all classes that include Celluloid
   #
 
-  # Raise an exception in caller context, but stay running
+  # Raise an exception in sender context, but stay running
   def abort(cause)
     cause = case cause
       when String then RuntimeError.new(cause)
@@ -326,11 +386,6 @@ module Celluloid
     Thread.current[:celluloid_chain_id]
   end
 
-  # Obtain the name of the current actor
-  def name
-    Actor.name
-  end
-
   # Obtain the running tasks for this actor
   def tasks
     Thread.current[:celluloid_actor].tasks.to_a
@@ -377,7 +432,7 @@ module Celluloid
     if actor
       actor.receive(timeout, &block)
     else
-      Thread.mailbox.receive(timeout, &block)
+      Celluloid.mailbox.receive(timeout, &block)
     end
   end
 
@@ -414,7 +469,7 @@ module Celluloid
   end
 
   # Perform a blocking or computationally intensive action inside an
-  # asynchronous thread pool, allowing the caller to continue processing other
+  # asynchronous thread pool, 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
@@ -424,20 +479,12 @@ module Celluloid
 
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
-    if meth
-      Actor.async Thread.current[:celluloid_actor].mailbox, meth, *args, &block
-    else
-      Thread.current[:celluloid_actor].proxy.async
-    end
+    Thread.current[:celluloid_actor].proxy.async meth, *args, &block
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
-    if meth
-      Actor.future Thread.current[:celluloid_actor].mailbox, meth, *args, &block
-    else
-      Thread.current[:celluloid_actor].proxy.future
-    end
+    Thread.current[:celluloid_actor].proxy.future meth, *args, &block
   end
 end
 
@@ -445,6 +492,7 @@ require 'celluloid/version'
 
 require 'celluloid/calls'
 require 'celluloid/condition'
+require 'celluloid/thread'
 require 'celluloid/core_ext'
 require 'celluloid/cpu_counter'
 require 'celluloid/fiber'
@@ -453,6 +501,7 @@ require 'celluloid/internal_pool'
 require 'celluloid/links'
 require 'celluloid/logger'
 require 'celluloid/mailbox'
+require 'celluloid/evented_mailbox'
 require 'celluloid/method'
 require 'celluloid/receivers'
 require 'celluloid/registry'
@@ -465,9 +514,11 @@ require 'celluloid/thread_handle'
 require 'celluloid/uuid'
 
 require 'celluloid/proxies/abstract_proxy'
+require 'celluloid/proxies/sync_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/future'
@@ -483,3 +534,4 @@ require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
 Celluloid.task_class = Celluloid::TaskFiber
 Celluloid.logger     = Logger.new(STDERR)
 Celluloid.shutdown_timeout = 10
+Celluloid.register_shutdown