celluloid 0.14.1 → 0.15.0.pre

data/lib/celluloid/autostart.rb

@@ -1,3 +1,3 @@
 require 'celluloid'
 
-Celluloid.boot
+Celluloid.start

data/lib/celluloid/call_chain.rb

@@ -0,0 +1,13 @@
+module Celluloid
+  class CallChain
+    def self.current_id=(value)
+      Thread.current[:celluloid_chain_id] = value
+      task = Thread.current[:celluloid_task]
+      task.chain_id = value if task
+    end
+
+    def self.current_id
+      Thread.current[:celluloid_chain_id]
+    end
+  end
+ end

data/lib/celluloid/calls.rb

@@ -54,7 +54,7 @@ module Celluloid
   class SyncCall < Call
     attr_reader :sender, :task, :chain_id
 
-    def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Thread.current[:celluloid_chain_id])
+    def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = CallChain.current_id)
       super(method, arguments, block)
 
       @sender   = sender
@@ -63,7 +63,7 @@ module Celluloid
     end
 
     def dispatch(obj)
-      Thread.current[:celluloid_chain_id] = @chain_id
+      CallChain.current_id = @chain_id
       result = super(obj)
       respond SuccessResponse.new(self, result)
     rescue Exception => ex
@@ -76,7 +76,7 @@ module Celluloid
       # Otherwise, it's a bug in this actor and should be reraised
       raise unless ex.is_a?(AbortError)
     ensure
-      Thread.current[:celluloid_chain_id] = nil
+      CallChain.current_id = nil
     end
 
     def cleanup
@@ -86,9 +86,6 @@ module Celluloid
 
     def respond(message)
       @sender << message
-    rescue MailboxError
-      # It's possible the sender exited or crashed before we could send a
-      # response to them.
     end
 
     def value
@@ -121,13 +118,13 @@ module Celluloid
   class AsyncCall < Call
 
     def dispatch(obj)
-      Thread.current[:celluloid_chain_id] = Celluloid.uuid
+      CallChain.current_id = Celluloid.uuid
       super(obj)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the sender made a mistake
       Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
     ensure
-      Thread.current[:celluloid_chain_id] = nil
+      CallChain.current_id = nil
     end
 
   end

data/lib/celluloid/condition.rb

@@ -1,7 +1,7 @@
 module Celluloid
-  class ConditionError < StandardError; end
+  class ConditionError < Celluloid::Error; end
 
-  # ConditionVariable-like signaling between tasks and actors
+  # ConditionVariable-like signaling between tasks and threads
   class Condition
     class Waiter
       def initialize(condition, task, mailbox)
@@ -23,11 +23,9 @@ module Celluloid
       end
     end
 
-    attr_reader :owner
-
     def initialize
       @mutex = Mutex.new
-      @tasks = []
+      @waiters = []
     end
 
     # Wait for the given signal and return the associated value
@@ -42,7 +40,7 @@ module Celluloid
       waiter = Waiter.new(self, task, Celluloid.mailbox)
 
       @mutex.synchronize do
-        @tasks << waiter
+        @waiters << waiter
       end
 
       result = Celluloid.suspend :condwait, waiter
@@ -53,7 +51,7 @@ module Celluloid
     # Send a signal to the first task waiting on this condition
     def signal(value = nil)
       @mutex.synchronize do
-        if waiter = @tasks.shift
+        if waiter = @waiters.shift
           waiter << SignalConditionRequest.new(waiter.task, value)
         else
           Logger.debug("Celluloid::Condition signaled spuriously")
@@ -61,11 +59,11 @@ module Celluloid
       end
     end
 
-    # Broadcast a value to all waiting tasks
+    # Broadcast a value to all waiting tasks and threads
     def broadcast(value = nil)
       @mutex.synchronize do
-        @tasks.each { |waiter| waiter << SignalConditionRequest.new(waiter.task, value) }
-        @tasks.clear
+        @waiters.each { |waiter| waiter << SignalConditionRequest.new(waiter.task, value) }
+        @waiters.clear
       end
     end
 

data/lib/celluloid/cpu_counter.rb

@@ -4,7 +4,7 @@ module Celluloid
   module CPUCounter
     case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
     when 'darwin'
-      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
+      @cores = Integer(`/usr/sbin/sysctl hw.ncpu`[/\d+/])
     when 'linux'
       @cores = if File.exists?("/sys/devices/system/cpu/present")
         File.read("/sys/devices/system/cpu/present").split('-').last.to_i+1

data/lib/celluloid/evented_mailbox.rb

@@ -13,26 +13,23 @@ module Celluloid
     def <<(message)
       @mutex.lock
       begin
-        if mailbox_full
-          Logger.debug "Discarded message: #{message}"
+        if mailbox_full || @dead
+          dead_letter(message)
           return
         end
         if message.is_a?(SystemEvent)
-          # Silently swallow system events sent to dead actors
-          return if @dead
-
           # SystemEvents are high priority messages so they get added to the
           # head of our message queue instead of the end
           @messages.unshift message
         else
-          raise MailboxError, "dead recipient" if @dead
           @messages << message
         end
 
         current_actor = Thread.current[:celluloid_actor]
         @reactor.wakeup unless current_actor && current_actor.mailbox == self
       rescue IOError
-        raise MailboxError, "dead recipient"
+        Logger.crash "reactor crashed", $!
+        dead_letter(message)
       ensure
         @mutex.unlock rescue nil
       end
@@ -59,7 +56,6 @@ module Celluloid
 
       message
     rescue IOError
-      shutdown # force shutdown of the mailbox
       raise MailboxShutdown, "mailbox shutdown called during receive"
     end
 
@@ -75,8 +71,9 @@ module Celluloid
 
     # Cleanup any IO objects this Mailbox may be using
     def shutdown
-      @reactor.shutdown
-      super
+      super do
+        @reactor.shutdown
+      end
     end
   end
 end

data/lib/celluloid/fsm.rb

@@ -13,7 +13,7 @@ module Celluloid
   #     #
   #     machine = MyMachine.new(current_actor)
   module FSM
-    class UnattachedError < StandardError; end # Not attached to an actor
+    class UnattachedError < Celluloid::Error; end # Not attached to an actor
 
     DEFAULT_STATE = :default # Default state name unless one is explicitly set
 

data/lib/celluloid/future.rb

@@ -8,8 +8,7 @@ module Celluloid
       return super unless block
 
       future = new
-      Celluloid.internal_pool.get do
-        Thread.current.role = :future
+      Celluloid::ThreadHandle.new(:future) do
         begin
           call = SyncCall.new(future, :call, args)
           call.dispatch(block)

data/lib/celluloid/internal_pool.rb

@@ -3,34 +3,76 @@ require 'thread'
 module Celluloid
   # Maintain a thread pool FOR SPEED!!
   class InternalPool
-    attr_accessor :busy_size, :idle_size, :max_idle
+    attr_accessor :max_idle
 
     def initialize
-      @pool = []
+      @group = ThreadGroup.new
       @mutex = Mutex.new
-      @busy_size = @idle_size = 0
+      @threads = []
 
-      reset
-    end
-
-    def reset
       # TODO: should really adjust this based on usage
       @max_idle = 16
+      @running = true
+    end
+
+    def busy_size
+      @threads.select(&:busy).size
+    end
+
+    def idle_size
+      @threads.reject(&:busy).size
+    end
+
+    def assert_running
+      unless running?
+        raise Error, "Thread pool is not running"
+      end
+    end
+
+    def assert_inactive
+      if active?
+        message = "Thread pool is still active"
+        if defined?(JRUBY_VERSION)
+          Celluloid.logger.warn message
+        else
+          raise Error, message
+        end
+      end
+    end
+
+    def running?
+      @running
+    end
+
+    def active?
+      to_a.any?
+    end
+
+    def each
+      @threads.each do |thread|
+        yield thread
+      end
+    end
+
+    def to_a
+      @threads
     end
 
     # Get a thread from the pool, running the given block
     def get(&block)
       @mutex.synchronize do
+        assert_running
+
         begin
-          if @pool.empty?
+          idle = @threads.reject(&:busy)
+          if idle.empty?
             thread = create
           else
-            thread = @pool.shift
-            @idle_size -= 1
+            thread = idle.first
           end
         end until thread.status # handle crashed threads
 
-        @busy_size += 1
+        thread.busy = true
         thread[:celluloid_queue] << block
         thread
       end
@@ -39,13 +81,12 @@ module Celluloid
     # Return a thread to the pool
     def put(thread)
       @mutex.synchronize do
-        if @pool.size >= @max_idle
+        thread.busy = false
+        if idle_size >= @max_idle
           thread[:celluloid_queue] << nil
+          @threads.delete(thread)
         else
           clean_thread_locals(thread)
-          @pool << thread
-          @idle_size += 1
-          @busy_size -= 1
         end
       end
     end
@@ -66,6 +107,8 @@ module Celluloid
       end
 
       thread[:celluloid_queue] = queue
+      @threads << thread
+      @group.add(thread)
       thread
     end
 
@@ -81,13 +124,27 @@ module Celluloid
 
     def shutdown
       @mutex.synchronize do
-        @max_idle = 0
-        @pool.each do |thread|
+        finalize
+        @threads.each do |thread|
           thread[:celluloid_queue] << nil
         end
       end
     end
-  end
 
-  self.internal_pool = InternalPool.new
-end
+    def kill
+      @mutex.synchronize do
+        finalize
+        @running = false
+
+        @threads.shift.kill until @threads.empty?
+        @group.list.each(&:kill)
+      end
+    end
+
+    private
+
+    def finalize
+      @max_idle = 0
+    end
+  end
+end

data/lib/celluloid/legacy.rb

@@ -1,41 +1,3 @@
-module Celluloid
-  class ActorProxy
-    # method_missing black magic to call bang predicate methods asynchronously
-    def method_missing(meth, *args, &block)
-      # bang methods are async calls
-      if meth.match(/!$/)
-        Logger.deprecate("'bang method'-style async syntax is deprecated and will be removed in Celluloid 1.0." +
-          "Call async methods with 'actor.async.method'.")
-
-        unbanged_meth = meth.to_s
-        unbanged_meth.slice!(-1, 1)
-        async unbanged_meth, *args, &block
-      else
-        super
-      end
-    end
-  end
-
-  module InstanceMethods
-    # Process async calls via method_missing
-    def method_missing(meth, *args, &block)
-      # bang methods are async calls
-      if meth.to_s.match(/!$/)
-        Logger.deprecate("'bang method'-style async syntax is deprecated and will be removed in Celluloid 1.0." +
-          "Call async methods with 'actor.async.method'.")
-
-        unbanged_meth = meth.to_s.sub(/!$/, '')
-        args.unshift unbanged_meth
-
-        async :__send__, *args, &block
-        return
-      end
-
-      super
-    end
-  end
-end
-
 class Thread
   def self.mailbox
     Celluloid.mailbox

data/lib/celluloid/mailbox.rb

@@ -1,8 +1,8 @@
 require 'thread'
 
 module Celluloid
-  class MailboxError < StandardError; end # you can't message the dead
-  class MailboxShutdown < StandardError; end # raised if the mailbox can no longer be used
+  class MailboxDead < Celluloid::Error; end # you can't receive from the dead
+  class MailboxShutdown < Celluloid::Error; end # raised if the mailbox can no longer be used
 
   # Actors communicate with asynchronous messages. Messages are buffered in
   # Mailboxes until Actors can act upon them.
@@ -26,19 +26,15 @@ module Celluloid
     def <<(message)
       @mutex.lock
       begin
-        if mailbox_full
-          Logger.debug "Discarded message: #{message}"
+        if mailbox_full || @dead
+          dead_letter(message)
           return
         end
         if message.is_a?(SystemEvent)
-          # Silently swallow system events sent to dead actors
-          return if @dead
-
           # SystemEvents are high priority messages so they get added to the
           # head of our message queue instead of the end
           @messages.unshift message
         else
-          raise MailboxError, "dead recipient" if @dead
           @messages << message
         end
 
@@ -55,7 +51,7 @@ module Celluloid
 
       @mutex.lock
       begin
-        raise MailboxError, "attempted to receive from a dead mailbox" if @dead
+        raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
 
         begin
           message = next_message(&block)
@@ -99,8 +95,11 @@ module Celluloid
 
     # Shut down this mailbox and clean up its contents
     def shutdown
+      raise MailboxDead, "mailbox already shutdown" if @dead
+
       @mutex.lock
       begin
+        yield if block_given?
         messages = @messages
         @messages = []
         @dead = true
@@ -108,7 +107,10 @@ module Celluloid
         @mutex.unlock rescue nil
       end
 
-      messages.each { |msg| msg.cleanup if msg.respond_to? :cleanup }
+      messages.each do |msg|
+        dead_letter msg
+        msg.cleanup if msg.respond_to? :cleanup
+      end
       true
     end
 
@@ -138,6 +140,11 @@ module Celluloid
     end
 
     private
+
+    def dead_letter(message)
+      Logger.debug "Discarded message (mailbox is dead): #{message}"
+    end
+
     def mailbox_full
       @max_size && @messages.size >= @max_size
     end