celluloid 0.12.4 → 0.13.0.pre

data/lib/celluloid/boot.rb

@@ -8,3 +8,16 @@ Celluloid.logger     = Logger.new(STDERR)
 # FIXME: We should set up the supervision hierarchy here
 Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
 Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+
+# 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

data/lib/celluloid/calls.rb

@@ -7,29 +7,69 @@ module Celluloid
       @method, @arguments, @block = method, arguments, block
     end
 
+    def dispatch(obj)
+      obj.public_send(@method, *@arguments, &@block)
+    rescue NoMethodError => ex
+      # Abort if the caller made a mistake
+      detect_missing_method(ex)
+
+      # Otherwise something blew up. Crash this actor
+      raise
+    rescue ArgumentError => ex
+      # Abort if the caller made a mistake
+      detect_argument_error(ex)
+
+      # Otherwise something blew up. Crash this actor
+      raise
+    end
+
+  private
+
+    # Detect NoMethodErrors made by the caller and abort
+    def detect_missing_method(ex)
+      ex.backtrace.each do |frame|
+        break if frame["celluloid/lib/celluloid/calls.rb"] || frame["`public_send'"]
+        return unless frame["`method_missing'"]
+      end
+
+      raise AbortError.new(ex)
+    end
+
+    # Detect ArgumentErrors made by the caller and abort
+    def detect_argument_error(ex)
+      if ex.backtrace[0]["`#{@method}'"] && ex.backtrace[1]["`public_send'"]
+        raise AbortError.new(ex)
+      end
+    end
   end
 
   # Synchronous calls wait for a response
   class SyncCall < Call
-    attr_reader :caller, :task
+    attr_reader :caller, :task, :chain_id
 
-    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:task])
+    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Thread.current[:celluloid_chain_id])
       super(method, arguments, block)
-      @caller = caller
-      @task = task
+
+      @caller   = caller
+      @task     = task
+      @chain_id = chain_id || Celluloid.uuid
     end
 
     def dispatch(obj)
-      result = obj.public_send(@method, *@arguments, &@block)
+      Thread.current[:celluloid_chain_id] = @chain_id
+      result = super(obj)
       respond SuccessResponse.new(self, result)
     rescue Exception => ex
       # Exceptions that occur during synchronous calls are reraised in the
       # context of the caller
       respond ErrorResponse.new(self, ex)
+
       # Aborting indicates a protocol error on the part of the caller
       # It should crash the caller, but the exception isn't reraised
       # Otherwise, it's a bug in this actor and should be reraised
-      ex.is_a?(AbortError) ? nil : raise
+      raise unless ex.is_a?(AbortError)
+    ensure
+      Thread.current[:celluloid_chain_id] = nil
     end
 
     def cleanup
@@ -43,17 +83,19 @@ module Celluloid
       # It's possible the caller exited or crashed before we could send a
       # response to them.
     end
-
   end
 
   # Asynchronous calls don't wait for a response
   class AsyncCall < Call
 
     def dispatch(obj)
-      obj.public_send(@method, *@arguments, &@block)
+      Thread.current[:celluloid_chain_id] = Celluloid.uuid
+      super(obj)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
       Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
+    ensure
+      Thread.current[:celluloid_chain_id] = nil
     end
 
   end

data/lib/celluloid/condition.rb

@@ -0,0 +1,64 @@
+module Celluloid
+  class ConditionError < StandardError; end
+
+  # ConditionVariable-like signaling between tasks and actors
+  class Condition
+    attr_reader :owner
+
+    def initialize
+      @mutex = Mutex.new
+      @owner = Actor.current
+      @tasks = []
+    end
+
+    # Wait for the given signal and return the associated value
+    def wait
+      raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
+
+      @mutex.synchronize do
+        raise ConditionError, "can't wait unless owner" unless Actor.current == @owner
+        @tasks << Task.current
+      end
+
+      result = Task.suspend :condwait
+      raise result if result.is_a? ConditionError
+      result
+    end
+
+    # Send a signal to the first task waiting on this condition
+    def signal(value = nil)
+       @mutex.synchronize do
+        if task = @tasks.shift
+          @owner.mailbox << SignalConditionRequest.new(task, value)
+        else
+          Logger.debug("Celluloid::Condition signaled spuriously")
+        end
+      end
+    end
+
+    # Broadcast a value to all waiting tasks
+    def broadcast(value = nil)
+      @mutex.synchronize do
+        @tasks.each { |task| @owner.mailbox << SignalConditionRequest.new(task, value) }
+        @tasks.clear
+      end
+    end
+
+    # Change the owner of this condition
+    def owner=(actor)
+      @mutex.synchronize do
+        if @owner != actor
+          @tasks.each do |task|
+            ex = ConditionError.new("ownership changed")
+            @owner.mailbox << SignalConditionRequest.new(task, ex)
+          end
+          @tasks.clear
+        end
+
+        @owner = actor
+      end
+    end
+
+    alias_method :inspect, :to_s
+  end
+end

data/lib/celluloid/core_ext.rb

@@ -6,7 +6,7 @@ class Thread
 
   # Retrieve the mailbox for the current thread or lazily initialize it
   def self.mailbox
-    current[:mailbox] ||= Celluloid::Mailbox.new
+    current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
   end
 
   # Receive a message either as an actor or through the local mailbox

data/lib/celluloid/cpu_counter.rb

@@ -0,0 +1,18 @@
+require 'rbconfig'
+
+module Celluloid
+  module CPUCounter
+    case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
+    when 'darwin'
+      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
+    when 'linux'
+      @cores = File.read("/proc/cpuinfo").scan(/(?:core id|processor)\s+: \d+/).uniq.size
+    when 'mingw', 'mswin'
+      @cores = Integer(`SET NUMBER_OF_PROCESSORS`[/\d+/])
+    else
+      @cores = nil
+    end
+
+    def self.cores; @cores; end
+  end
+end

data/lib/celluloid/future.rb

@@ -4,8 +4,11 @@ module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
   class Future
+    attr_reader :address
+    
     # Create a future bound to a given receiver, or with a block to compute
     def initialize(*args, &block)
+      @address = Celluloid.uuid
       @mutex = Mutex.new
       @ready = false
       @result = nil
@@ -13,7 +16,7 @@ module Celluloid
 
       if block
         @call = SyncCall.new(self, :call, args)
-        InternalPool.get do
+        Celluloid.internal_pool.get do
           begin
             @call.dispatch(block)
           rescue

data/lib/celluloid/internal_pool.rb

@@ -2,61 +2,79 @@ require 'thread'
 
 module Celluloid
   # Maintain a thread pool FOR SPEED!!
-  module InternalPool
-    @pool = []
-    @mutex = Mutex.new
+  class InternalPool
+    attr_accessor :busy_size, :idle_size, :max_idle
 
-    # TODO: should really adjust this based on usage
-    @max_idle = 16
+    def initialize
+      @pool = []
+      @mutex = Mutex.new
+      @busy_size = @idle_size = 0
 
-    class << self
-      attr_accessor :max_idle
-
-      # Get a thread from the pool, running the given block
-      def get(&block)
-        @mutex.synchronize do
-          begin
-            if @pool.empty?
-              thread = create
-            else
-              thread = @pool.shift
-            end
-          end until thread.status # handle crashed threads
-
-          thread[:queue] << block
-          thread
-        end
-      end
+      # TODO: should really adjust this based on usage
+      @max_idle = 16
+    end
 
-      # Return a thread to the pool
-      def put(thread)
-        @mutex.synchronize do
-          if @pool.size >= @max_idle
-            thread[:queue] << nil
+    # Get a thread from the pool, running the given block
+    def get(&block)
+      @mutex.synchronize do
+        begin
+          if @pool.empty?
+            thread = create
           else
-            @pool << thread
+            thread = @pool.shift
+            @idle_size -= 1
           end
+        end until thread.status # handle crashed threads
+
+        @busy_size += 1
+        thread[:celluloid_queue] << block
+        thread
+      end
+    end
+
+    # Return a thread to the pool
+    def put(thread)
+      @mutex.synchronize do
+        if @pool.size >= @max_idle
+          thread[:celluloid_queue] << nil
+        else
+          clean_thread_locals(thread)
+          @pool << thread
+          @idle_size += 1
+          @busy_size -= 1
         end
       end
+    end
 
-      # Create a new thread with an associated queue of procs to run
-      def create
-        queue = Queue.new
-        thread = Thread.new do
-          while proc = queue.pop
-            begin
-              proc.call
-            rescue => ex
-              Logger.crash("thread crashed", ex)
-            end
-
-            put thread
+    # Create a new thread with an associated queue of procs to run
+    def create
+      queue = Queue.new
+      thread = Thread.new do
+        while proc = queue.pop
+          begin
+            proc.call
+          rescue => ex
+            Logger.crash("thread crashed", ex)
           end
+
+          put thread
         end
+      end
 
-        thread[:queue] = queue
-        thread
+      thread[:celluloid_queue] = queue
+      thread
+    end
+
+    # Clean the thread locals of an incoming thread
+    def clean_thread_locals(thread)
+      thread.keys.each do |key|
+        next if key == :celluloid_queue
+
+        # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
+        thread[key] = nil
       end
     end
   end
-end
+
+  self.internal_pool = InternalPool.new
+end

data/lib/celluloid/legacy.rb

@@ -0,0 +1,46 @@
+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)
+        Actor.async @mailbox, unbanged_meth, *args, &block
+      else
+        Actor.call  @mailbox, meth, *args, &block
+      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
+
+        call = AsyncCall.new(:__send__, args, block)
+        begin
+          Thread.current[:celluloid_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
+end

data/lib/celluloid/links.rb

@@ -27,11 +27,6 @@ module Celluloid
       @links.each { |_, actor| yield(actor) }
     end
 
-    # Send an event message to all actors
-    def send_event(event)
-      each { |actor| actor.mailbox << event }
-    end
-
     # Generate a string representation
     def inspect
       links = self.map(&:inspect).join(',')

data/lib/celluloid/logger.rb

@@ -37,10 +37,10 @@ module Celluloid
       end
     end
 
-    # Format an exception message
-    def format_exception(exception)
-      str = "#{exception.class}: #{exception.to_s}\n"
-      str << exception.backtrace.join("\n")
+    # Note a deprecation
+    def deprecate(message)
+      trace = caller.join("\n\t")
+      warn "DEPRECATION WARNING: #{message}\n\t#{trace}"
     end
 
     # Define an exception handler
@@ -49,5 +49,11 @@ module Celluloid
       @exception_handlers << block
       nil
     end
+
+    # Format an exception message
+    def format_exception(exception)
+      str = "#{exception.class}: #{exception.to_s}\n\t"
+      str << exception.backtrace.join("\n\t")
+    end
   end
 end

data/lib/celluloid/mailbox.rb

@@ -10,9 +10,10 @@ module Celluloid
     include Enumerable
 
     # A unique address at which this mailbox can be found
-    alias_method :address, :object_id
+    attr_reader :address
 
     def initialize
+      @address   = Celluloid.uuid
       @messages  = []
       @mutex     = Mutex.new
       @dead      = false