celluloid 0.15.2 → 0.16.0.pre2

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,33 @@
-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?
+      end
+    end
+  end
+end

data/lib/celluloid/evented_mailbox.rb

@@ -38,23 +38,16 @@ module Celluloid
 
     # 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)
+      # 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)
+
+      # This is a hack to get the main Actor#run loop to recompute the timeout:
+      raise TimeoutError
     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,7 +6,6 @@ module Celluloid
     attr_accessor :max_idle
 
     def initialize
-      @group = ThreadGroup.new
       @mutex = Mutex.new
       @threads = []
 
@@ -108,7 +107,6 @@ module Celluloid
 
       thread[:celluloid_queue] = queue
       @threads << thread
-      @group.add(thread)
       thread
     end
 
@@ -137,7 +135,6 @@ module Celluloid
         @running = false
 
         @threads.shift.kill until @threads.empty?
-        @group.list.each(&:kill)
       end
     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

@@ -58,10 +58,11 @@ module Celluloid
 
           unless message
             if timeout
+              # TODO: use hitimes/timers instead of Time.now
               now = Time.now
               wait_until ||= now + timeout
               wait_interval = wait_until - now
-              return if wait_interval <= 0
+              raise(TimeoutError, "mailbox timeout exceeded", nil) if wait_interval <= 0
             else
               wait_interval = nil
             end
@@ -76,23 +77,6 @@ module Celluloid
       end
     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)
-        end
-
-        message = @messages.slice!(index, 1).first if index
-      else
-        message = @messages.shift
-      end
-
-      message
-    end
-
     # Shut down this mailbox and clean up its contents
     def shutdown
       raise MailboxDead, "mailbox already shutdown" if @dead
@@ -141,6 +125,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

data/lib/celluloid/probe.rb

@@ -0,0 +1,73 @@
+require 'celluloid'
+
+$CELLULOID_MONITORING = true
+
+module Celluloid
+  class Probe
+    include Celluloid
+    include Celluloid::Notifications
+
+    NOTIFICATIONS_TOPIC_BASE = 'celluloid.events.%s'
+    INITIAL_EVENTS = Queue.new
+
+    class << self
+      def run
+        # spawn the actor if not found
+        supervise_as(:probe_actor) unless Actor[:probe_actor] && Actor[:probe_actor].alive?
+      end
+
+      def actor_created(actor)
+        trigger_event(:actor_created, actor)
+      end
+
+      def actor_named(actor)
+        trigger_event(:actor_named, actor)
+      end
+
+      def actor_died(actor)
+        trigger_event(:actor_died, actor)
+      end
+
+      def actors_linked(a, b)
+        a = find_actor(a)
+        b = find_actor(b)
+        trigger_event(:actors_linked, a, b)
+      end
+
+      private
+
+      def trigger_event(name, *args)
+        return unless $CELLULOID_MONITORING
+        probe_actor = Actor[:probe_actor]
+        if probe_actor
+          probe_actor.async.dispatch_event(name, args)
+        else
+          INITIAL_EVENTS << [name, args]
+        end
+      end
+
+      def find_actor(obj)
+        if obj.__send__(:class) == Actor
+          obj
+        elsif owner = obj.instance_variable_get(OWNER_IVAR)
+          owner
+        end
+      end
+    end
+
+    def initialize
+      async.first_run
+    end
+
+    def first_run
+      until INITIAL_EVENTS.size == 0
+        event = INITIAL_EVENTS.pop
+        dispatch_event(*event)
+      end
+    end
+
+    def dispatch_event(cmd, args)
+      publish(NOTIFICATIONS_TOPIC_BASE % cmd, args)
+    end
+  end
+end

data/lib/celluloid/properties.rb

@@ -9,7 +9,7 @@ module Celluloid
 
       ancestors.first.send(:define_singleton_method, name) do |value = nil, *extra|
         if value
-          value = value ? [value, *extra] : [] if multi
+          value = value ? [value, *send(name), *extra].uniq : [] if multi
           instance_variable_set(ivar_name, value)
         elsif instance_variables.include?(ivar_name)
           instance_variable_get(ivar_name)
@@ -21,4 +21,4 @@ module Celluloid
       end
     end
   end
-end
+end

data/lib/celluloid/proxies/actor_proxy.rb

@@ -1,59 +1,27 @@
 module Celluloid
-  # A proxy object returned from Celluloid::Actor.new/new_link which converts
-  # the normal Ruby method protocol into an inter-actor message protocol
-  class ActorProxy < SyncProxy
-    attr_reader :thread
+  # A proxy which controls the Actor lifecycle
+  class ActorProxy < AbstractProxy
+    attr_reader :thread, :mailbox
 
     # Used for reflecting on proxy objects themselves
     def __class__; ActorProxy; end
 
-    def initialize(actor)
-      @thread = actor.thread
-
-      super(actor.mailbox, actor.subject.class.to_s)
-      @sync_proxy   = SyncProxy.new(@mailbox, @klass)
-      @async_proxy  = AsyncProxy.new(@mailbox, @klass)
-      @future_proxy = FutureProxy.new(@mailbox, @klass)
-    end
-
-    def _send_(meth, *args, &block)
-      method_missing :__send__, meth, *args, &block
+    def initialize(thread, mailbox)
+      @thread = thread
+      @mailbox = mailbox
     end
 
     def inspect
-      method_missing :inspect
+      # TODO: use a system event to fetch actor state: tasks?
+      "#<Celluloid::ActorProxy(#{@mailbox.address}) alive>"
     rescue DeadActorError
-      "#<Celluloid::ActorProxy(#{@klass}) dead>"
-    end
-
-    def method(name)
-      Method.new(self, name)
+      "#<Celluloid::ActorProxy(#{@mailbox.address}) dead>"
     end
 
     def alive?
       @mailbox.alive?
     end
 
-    alias_method :sync, :method_missing
-
-    # Obtain an async proxy or explicitly invoke a named async method
-    def async(method_name = nil, *args, &block)
-      if method_name
-        @async_proxy.method_missing method_name, *args, &block
-      else
-        @async_proxy
-      end
-    end
-
-    # Obtain a future proxy or explicitly invoke a named future method
-    def future(method_name = nil, *args, &block)
-      if method_name
-        @future_proxy.method_missing method_name, *args, &block
-      else
-        @future_proxy
-      end
-    end
-
     # Terminate the associated actor
     def terminate
       terminate!