celluloid 0.15.2 → 0.16.0

data/lib/celluloid/cell.rb

@@ -0,0 +1,89 @@
+module Celluloid
+  OWNER_IVAR = :@celluloid_owner # reference to owning actor
+
+  # Wrap the given subject with an Cell
+  class Cell
+    class ExitHandler
+      def initialize(behavior, subject, method_name)
+        @behavior = behavior
+        @subject = subject
+        @method_name = method_name
+      end
+
+      def call(event)
+        @behavior.task(:exit_handler, @method_name) do
+          @subject.send(@method_name, event.actor, event.reason)
+        end
+      end
+    end
+
+    def initialize(subject, options, actor_options)
+      @actor                      = Actor.new(self, actor_options)
+      @subject                    = subject
+      @receiver_block_executions  = options[:receiver_block_executions]
+      @exclusive_methods          = options[:exclusive_methods]
+      @finalizer                  = options[:finalizer]
+
+      @subject.instance_variable_set(OWNER_IVAR, @actor)
+
+      if exit_handler_name = options[:exit_handler_name]
+        @actor.exit_handler = ExitHandler.new(self, @subject, exit_handler_name)
+      end
+
+      @actor.handle(Call) do |message|
+        invoke(message)
+      end
+      @actor.handle(BlockCall) do |message|
+        task(:invoke_block) { message.dispatch }
+      end
+      @actor.handle(BlockResponse, Response) do |message|
+        message.dispatch
+      end
+
+      @actor.start
+      @proxy = (options[:proxy_class] || CellProxy).new(@actor.proxy, @actor.mailbox, @subject.class.to_s)
+    end
+    attr_reader :proxy, :subject
+
+    def invoke(call)
+      meth = call.method
+      if meth == :__send__
+        meth = call.arguments.first
+      end
+      if @receiver_block_executions && meth
+        if @receiver_block_executions.include?(meth.to_sym)
+          call.execute_block_on_receiver
+        end
+      end
+
+      task(:call, meth, :dangerous_suspend => meth == :initialize) {
+        call.dispatch(@subject)
+      }
+    end
+
+    def task(task_type, method_name = nil, meta = nil, &block)
+      meta ||= {}
+      meta.merge!(:method_name => method_name)
+      @actor.task(task_type, meta) do
+        if @exclusive_methods && method_name && @exclusive_methods.include?(method_name.to_sym)
+          Celluloid.exclusive { yield }
+        else
+          yield
+        end
+      end
+    end
+
+    # Run the user-defined finalizer, if one is set
+    def shutdown
+      return unless @finalizer && @subject.respond_to?(@finalizer, true)
+
+      task(:finalizer, @finalizer, :dangerous_suspend => true) do
+        begin
+          @subject.__send__(@finalizer)
+        rescue => ex
+          Logger.crash("#{@subject.class} finalizer crashed!", ex)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/condition.rb

@@ -4,10 +4,11 @@ module Celluloid
   # ConditionVariable-like signaling between tasks and threads
   class Condition
     class Waiter
-      def initialize(condition, task, mailbox)
+      def initialize(condition, task, mailbox, timeout)
         @condition = condition
         @task = task
         @mailbox = mailbox
+        @timeout = timeout
       end
       attr_reader :condition, :task
 
@@ -16,9 +17,14 @@ module Celluloid
       end
 
       def wait
-        message = @mailbox.receive do |msg|
-          msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
-        end
+        begin
+          message = @mailbox.receive(@timeout) do |msg|
+            msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
+          end
+        rescue TimeoutError
+          raise ConditionError, "timeout after #{@timeout.inspect} seconds"
+        end until message
+
         message.value
       end
     end
@@ -29,21 +35,30 @@ module Celluloid
     end
 
     # Wait for the given signal and return the associated value
-    def wait
+    def wait(timeout = nil)
       raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
-      if Thread.current[:celluloid_actor]
+      if actor = Thread.current[:celluloid_actor]
         task = Task.current
+        if timeout
+          bt = caller
+          timer = actor.timers.after(timeout) do
+            exception = ConditionError.new("timeout after #{timeout.inspect} seconds")
+            exception.set_backtrace bt
+            task.resume exception
+          end
+        end
       else
         task = Thread.current
       end
-      waiter = Waiter.new(self, task, Celluloid.mailbox)
+      waiter = Waiter.new(self, task, Celluloid.mailbox, timeout)
 
       @mutex.synchronize do
         @waiters << waiter
       end
 
       result = Celluloid.suspend :condwait, waiter
+      timer.cancel if timer
       raise result if result.is_a? ConditionError
       result
     end
@@ -54,7 +69,9 @@ module Celluloid
         if waiter = @waiters.shift
           waiter << SignalConditionRequest.new(waiter.task, value)
         else
-          Logger.debug("Celluloid::Condition signaled spuriously")
+          Logger.with_backtrace(caller(3)) do |logger|
+            logger.debug("Celluloid::Condition signaled spuriously")
+          end
         end
       end
     end

data/lib/celluloid/cpu_counter.rb

@@ -1,24 +1,34 @@
-require 'rbconfig'
-
 module Celluloid
   module CPUCounter
-    case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
-    when 'darwin'
-      @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
-      else
-        Dir["/sys/devices/system/cpu/cpu*"].select { |n| n=~/cpu\d+/ }.count
+    class << self
+      def cores
+        @cores ||= count_cores
       end
-    when 'mingw', 'mswin'
-      @cores = Integer(ENV["NUMBER_OF_PROCESSORS"][/\d+/])
-    else
-      @cores = nil
-    end
 
-    def self.cores; @cores; end
-  end
-end
+      private
 
+      def count_cores
+        result = from_env || from_sysdev || from_sysctl
+        Integer(result.to_s[/\d+/], 10) if result
+      end
+
+      def from_env
+        result = ENV['NUMBER_OF_PROCESSORS']
+        result if result
+      end
 
+      def from_sysdev
+        ::IO.read('/sys/devices/system/cpu/present').split('-').last.to_i + 1
+      rescue Errno::ENOENT
+        result = Dir['/sys/devices/system/cpu/cpu*'].count { |n| n =~ /cpu\d+/ }
+        result unless result.zero?
+      end
+
+      def from_sysctl
+        result = `sysctl -n hw.ncpu`
+        result if $?.success?
+      rescue Errno::ENOENT
+      end
+    end
+  end
+end

data/lib/celluloid/evented_mailbox.rb

@@ -37,24 +37,18 @@ module Celluloid
     end
 
     # Receive a message from the Mailbox
-    def receive(timeout = nil, &block)
-      message = next_message(block)
-
-      until message
-        if timeout
-          now = Time.now
-          wait_until ||= now + timeout
-          wait_interval = wait_until - now
-          return if wait_interval < 0
-        else
-          wait_interval = nil
-        end
-
-        @reactor.run_once(wait_interval)
-        message = next_message(block)
+    def check(timeout = nil, &block)
+      # Get a message if it is available and process it immediately if possible:
+      if message = next_message(block)
+        return message
       end
 
-      message
+      # ... otherwise, run the reactor once, either blocking or will return
+      # after the given timeout:
+      @reactor.run_once(timeout)
+
+      # No message was received:
+      return nil
     rescue IOError
       raise MailboxShutdown, "mailbox shutdown called during receive"
     end

data/lib/celluloid/exceptions.rb

@@ -0,0 +1,23 @@
+module Celluloid
+  # Base class of all Celluloid errors
+  Error = Class.new(StandardError)
+
+  # Don't do Actor-like things outside Actor scope
+  NotActorError = Class.new(Celluloid::Error)
+
+  # Trying to do something to a dead actor
+  DeadActorError = Class.new(Celluloid::Error)
+
+  # A timeout occured before the given request could complete
+  TimeoutError = Class.new(Celluloid::Error)
+
+  # The sender made an error, not the current actor
+  class AbortError < Celluloid::Error
+    attr_reader :cause
+
+    def initialize(cause)
+      @cause = cause
+      super "caused by #{cause.inspect}: #{cause.to_s}"
+    end
+  end
+end

data/lib/celluloid/future.rb

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

data/lib/celluloid/handlers.rb

@@ -0,0 +1,41 @@
+require 'set'
+
+module Celluloid
+  class Handlers
+    def initialize
+      @handlers = Set.new
+    end
+
+    def handle(*patterns, &block)
+      patterns.each do |pattern|
+        handler = Handler.new pattern, block
+        @handlers << handler
+      end
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      if handler = @handlers.find { |h| h.match(message) }
+        handler.call message
+        handler
+      end
+    end
+  end
+
+  # Methods blocking on a call to receive
+  class Handler
+    def initialize(pattern, block)
+      @pattern = pattern
+      @block = block
+    end
+
+    # Match a message with this receiver's block
+    def match(message)
+      @pattern === message
+    end
+
+    def call(message)
+      @block.call message
+    end
+  end
+end

data/lib/celluloid/internal_pool.rb

@@ -6,9 +6,11 @@ module Celluloid
     attr_accessor :max_idle
 
     def initialize
-      @group = ThreadGroup.new
       @mutex = Mutex.new
-      @threads = []
+      @idle_threads = []
+      @all_threads  = []
+      @busy_size = 0
+      @idle_size = 0
 
       # TODO: should really adjust this based on usage
       @max_idle = 16
@@ -16,17 +18,15 @@ module Celluloid
     end
 
     def busy_size
-      @threads.select(&:busy).size
+      @busy_size
     end
 
     def idle_size
-      @threads.reject(&:busy).size
+      @idle_size
     end
 
     def assert_running
-      unless running?
-        raise Error, "Thread pool is not running"
-      end
+      raise Error, "Thread pool is not running" unless running?
     end
 
     def assert_inactive
@@ -45,17 +45,15 @@ module Celluloid
     end
 
     def active?
-      to_a.any?
+      busy_size + idle_size > 0
     end
 
     def each
-      @threads.each do |thread|
-        yield thread
-      end
+      to_a.each {|thread| yield thread }
     end
 
     def to_a
-      @threads
+      @mutex.synchronize { @all_threads.dup }
     end
 
     # Get a thread from the pool, running the given block
@@ -64,15 +62,16 @@ module Celluloid
         assert_running
 
         begin
-          idle = @threads.reject(&:busy)
-          if idle.empty?
+          if @idle_threads.empty?
             thread = create
           else
-            thread = idle.first
+            thread = @idle_threads.pop
+            @idle_size = @idle_threads.length
           end
         end until thread.status # handle crashed threads
 
         thread.busy = true
+        @busy_size += 1
         thread[:celluloid_queue] << block
         thread
       end
@@ -82,15 +81,46 @@ module Celluloid
     def put(thread)
       @mutex.synchronize do
         thread.busy = false
-        if idle_size >= @max_idle
+        if idle_size + 1 >= @max_idle
           thread[:celluloid_queue] << nil
-          @threads.delete(thread)
+          @busy_size -= 1
+          @all_threads.delete(thread)
         else
+          @idle_threads.push thread
+          @busy_size -= 1
+          @idle_size = @idle_threads.length
           clean_thread_locals(thread)
         end
       end
     end
 
+    def shutdown
+      @mutex.synchronize do
+        finalize
+        @all_threads.each do |thread|
+          thread[:celluloid_queue] << nil
+        end
+        @all_threads.clear
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    def kill
+      @mutex.synchronize do
+        finalize
+        @running = false
+
+        @all_threads.shift.kill until @all_threads.empty?
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    private
+
     # Create a new thread with an associated queue of procs to run
     def create
       queue = Queue.new
@@ -107,8 +137,8 @@ module Celluloid
       end
 
       thread[:celluloid_queue] = queue
-      @threads << thread
-      @group.add(thread)
+      # @idle_threads << thread
+      @all_threads << thread
       thread
     end
 
@@ -122,27 +152,6 @@ module Celluloid
       end
     end
 
-    def shutdown
-      @mutex.synchronize do
-        finalize
-        @threads.each do |thread|
-          thread[:celluloid_queue] << nil
-        end
-      end
-    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

data/lib/celluloid/logger.rb

@@ -1,8 +1,38 @@
 module Celluloid
   module Logger
+    class WithBacktrace
+      def initialize(backtrace)
+        @backtrace = backtrace
+      end
+
+      def debug(string)
+        Celluloid.logger.debug(decorate(string))
+      end
+
+      def info(string)
+        Celluloid.logger.info(decorate(string))
+      end
+
+      def warn(string)
+        Celluloid.logger.warn(decorate(string))
+      end
+
+      def error(string)
+        Celluloid.logger.error(decorate(string))
+      end
+
+      def decorate(string)
+        [string, @backtrace].join("\n\t")
+      end
+    end
+
     @exception_handlers = []
     module_function
 
+    def with_backtrace(backtrace)
+      yield WithBacktrace.new(backtrace) if Celluloid.logger
+    end
+
     # Send a debug message
     def debug(string)
       Celluloid.logger.debug(string) if Celluloid.logger

data/lib/celluloid/logging/incident_logger.rb

@@ -111,7 +111,7 @@ module Celluloid
       end
       messages.sort
     end
-    
+
     def clear
       @buffer_mutex.synchronize do
         @buffers.each { |buffer| buffer.clear }

data/lib/celluloid/mailbox.rb

@@ -45,52 +45,39 @@ module Celluloid
       end
     end
 
-    # Receive a message from the Mailbox
-    def receive(timeout = nil, &block)
+    # Receive a message from the Mailbox. May return nil and may return before
+    # the specified timeout.
+    def check(timeout = nil, &block)
       message = nil
 
       @mutex.lock
       begin
         raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
 
-        begin
+        Timers::Wait.for(timeout) do |remaining|
           message = next_message(&block)
 
-          unless message
-            if timeout
-              now = Time.now
-              wait_until ||= now + timeout
-              wait_interval = wait_until - now
-              return if wait_interval <= 0
-            else
-              wait_interval = nil
-            end
-
-            @condition.wait(@mutex, wait_interval)
-          end
-        end until message
-
-        message
+          break message if message
+
+          @condition.wait(@mutex, remaining)
+        end
       ensure
         @mutex.unlock rescue nil
       end
+      
+      return message
     end
 
-    # Retrieve the next message in the mailbox
-    def next_message
-      message = nil
-
-      if block_given?
-        index = @messages.index do |msg|
-          yield(msg) || msg.is_a?(SystemEvent)
+    # Receive a letter from the mailbox. Guaranteed to return a message. If
+    # timeout is exceeded, raise a TimeoutError.
+    def receive(timeout = nil, &block)
+      Timers::Wait.for(timeout) do |remaining|
+        if message = check(timeout, &block)
+          return message
         end
-
-        message = @messages.slice!(index, 1).first if index
-      else
-        message = @messages.shift
       end
-
-      message
+      
+      raise TimeoutError.new("receive timeout exceeded")
     end
 
     # Shut down this mailbox and clean up its contents
@@ -141,6 +128,23 @@ module Celluloid
 
     private
 
+    # Retrieve the next message in the mailbox
+    def next_message
+      message = nil
+
+      if block_given?
+        index = @messages.index do |msg|
+          yield(msg) || msg.is_a?(SystemEvent)
+        end
+
+        message = @messages.slice!(index, 1).first if index
+      else
+        message = @messages.shift
+      end
+
+      message
+    end
+
     def dead_letter(message)
       Logger.debug "Discarded message (mailbox is dead): #{message}" if $CELLULOID_DEBUG
     end

data/lib/celluloid/method.rb

@@ -13,6 +13,14 @@ module Celluloid
       @proxy.method_missing(:method, @name).arity
     end
 
+    def name
+      @proxy.method_missing(:method, @name).name
+    end
+
+    def parameters
+      @proxy.method_missing(:method, @name).parameters
+    end
+
     def call(*args, &block)
       @proxy.__send__(@name, *args, &block)
     end

data/lib/celluloid/pool_manager.rb

@@ -10,7 +10,7 @@ module Celluloid
     finalizer :__shutdown__
 
     def initialize(worker_class, options = {})
-      @size = options[:size] || [Celluloid.cores, 2].max
+      @size = options[:size] || [Celluloid.cores || 2, 2].max
       raise ArgumentError, "minimum pool size is 2" if @size < 2
 
       @worker_class = worker_class
@@ -24,7 +24,7 @@ module Celluloid
     end
 
     def __shutdown__
-      terminators = (@idle + @busy).each do |actor|
+      terminators = (@idle + @busy).map do |actor|
         begin
           actor.future(:terminate)
         rescue DeadActorError
@@ -81,6 +81,23 @@ module Celluloid
       @size
     end
 
+    def size=(new_size)
+      new_size = [0, new_size].max
+
+      if new_size > size
+        delta = new_size - size
+        delta.times { @idle << @worker_class.new_link(*@args) }
+      else
+        (size - new_size).times do
+          worker = __provision_worker__
+          unlink worker
+          @busy.delete worker
+          worker.terminate
+        end
+      end
+      @size = new_size
+    end
+
     def busy_size
       @busy.length
     end