celluloid 0.11.1 → 0.12.0.pre

data/lib/celluloid/actor_proxy.rb

@@ -2,8 +2,8 @@ module Celluloid
   # A proxy object returned from Celluloid::Actor.spawn/spawn_link which
   # dispatches calls and casts to normal Ruby objects which are running inside
   # of their own threads.
-  class ActorProxy
-    attr_reader :mailbox
+  class ActorProxy < BasicObject
+    attr_reader :mailbox, :thread
 
     def initialize(actor)
       @mailbox, @thread, @klass = actor.mailbox, actor.thread, actor.subject.class.to_s
@@ -13,6 +13,19 @@ module Celluloid
       Actor.call @mailbox, :__send__, meth, *args, &block
     end
 
+    # Needed for storing proxies in data structures
+    needed = [:object_id, :__id__, :hash] - instance_methods
+    if needed.any?
+      include ::Kernel.dup.module_eval {
+        undef_method *(instance_methods - needed)
+        self
+      }
+
+      # rubinius bug?  These methods disappear when we include hacked kernel
+      define_method :==, ::BasicObject.instance_method(:==) unless instance_methods.include?(:==)
+      alias_method(:equal?, :==) unless instance_methods.include?(:equal?)
+    end
+
     def class
       Actor.call @mailbox, :__send__, :class
     end
@@ -29,14 +42,18 @@ module Celluloid
       Actor.call @mailbox, :kind_of?, klass
     end
 
-    def respond_to?(meth)
-      Actor.call @mailbox, :respond_to?, meth
+    def respond_to?(meth, include_private = false)
+      Actor.call @mailbox, :respond_to?, meth, include_private
     end
 
     def methods(include_ancestors = true)
       Actor.call @mailbox, :methods, include_ancestors
     end
 
+    def method(name)
+      Method.new(self, name)
+    end
+
     def alive?
       @mailbox.alive?
     end
@@ -65,28 +82,14 @@ module Celluloid
     # Terminate the associated actor
     def terminate
       terminate!
-      join
+      Actor.join(self)
       nil
     end
 
     # Terminate the associated actor asynchronously
     def terminate!
-      raise DeadActorError, "actor already terminated" unless alive?
-      @mailbox.system_event TerminationRequest.new
-    end
-
-    # Forcibly kill a given actor
-    def kill
-      @thread.kill
-      begin
-        @mailbox.shutdown
-      rescue DeadActorError
-      end
-    end
-
-    # Wait for an actor to terminate
-    def join
-      @thread.join
+      ::Kernel.raise DeadActorError, "actor already terminated" unless alive?
+      @mailbox << TerminationRequest.new
     end
 
     # method_missing black magic to call bang predicate methods asynchronously

data/lib/celluloid/boot.rb

@@ -0,0 +1,9 @@
+# Things to run after Celluloid is fully loaded
+
+# Configure default systemwide settings
+Celluloid.logger     = Logger.new STDERR
+Celluloid.task_class = Celluloid::TaskFiber
+
+# Launch the notifications fanout actor
+# FIXME: We should set up the supervision hierarchy here
+Celluloid::Notifications::Fanout.supervise_as :notifications_fanout

data/lib/celluloid/calls.rb

@@ -9,7 +9,7 @@ module Celluloid
 
     def check_signature(obj)
       unless obj.respond_to? @method
-        raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}"
+        raise NoMethodError, "undefined method `#{@method}' for #{obj.to_s}"
       end
 
       begin
@@ -39,7 +39,7 @@ module Celluloid
   class SyncCall < Call
     attr_reader :caller, :task
 
-    def initialize(caller, method, arguments = [], block = nil, task = Fiber.current.task)
+    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:task])
       super(method, arguments, block)
       @caller = caller
       @task = task
@@ -99,7 +99,7 @@ module Celluloid
       obj.send(@method, *@arguments, &@block)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
-      Logger.crash("#{obj.class}: async call `#{@method}' aborted!", ex)
+      Logger.crash("#{obj.class}: async call `#{@method}' aborted!", ex.cause)
     end
   end
 end

data/lib/celluloid/core_ext.rb

@@ -17,9 +17,4 @@ class Thread
       mailbox.receive(timeout, &block)
     end
   end
-end
-
-class Fiber
-  # Celluloid::Task associated with this Fiber
-  attr_accessor :task
-end
+end

data/lib/celluloid/cpu_counter.rb

@@ -7,6 +7,8 @@ module Celluloid
       @cores = Integer(`sysctl hw.ncpu`[/\d+/])
     when 'linux'
       @cores = File.read("/proc/cpuinfo").scan(/core id\s+: \d+/).uniq.size
+    when 'mingw', 'mswin'
+      @cores = Integer(`SET NUMBER_OF_PROCESSORS`[/\d+/])
     else
       @cores = nil
     end

data/lib/celluloid/future.rb

@@ -91,6 +91,9 @@ module Celluloid
     end
     alias_method :<<, :signal
 
+    # Is the future ready yet?
+    def ready?; @ready; end
+
     # Inspect this Celluloid::Future
     alias_method :inspect, :to_s
 

data/lib/celluloid/links.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 module Celluloid
   # Linked actors send each other system events
   class Links
@@ -31,7 +29,7 @@ module Celluloid
 
     # Send an event message to all actors
     def send_event(event)
-      each { |actor| actor.mailbox.system_event event }
+      each { |actor| actor.mailbox << event }
     end
 
     # Generate a string representation

data/lib/celluloid/mailbox.rb

@@ -13,9 +13,9 @@ module Celluloid
     alias_method :address, :object_id
 
     def initialize
-      @messages = []
-      @mutex = Mutex.new
-      @dead = false
+      @messages  = []
+      @mutex     = Mutex.new
+      @dead      = false
       @condition = ConditionVariable.new
     end
 
@@ -23,9 +23,18 @@ module Celluloid
     def <<(message)
       @mutex.lock
       begin
-        raise MailboxError, "dead recipient" if @dead
+        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
 
-        @messages << message
         @condition.signal
         nil
       ensure
@@ -33,20 +42,6 @@ module Celluloid
       end
     end
 
-    # Add a high-priority system event to the Mailbox
-    def system_event(event)
-      @mutex.lock
-      begin
-        unless @dead # Silently fail if messages are sent to dead actors
-          @messages.unshift event
-          @condition.signal
-        end
-        nil
-      ensure
-        @mutex.unlock rescue nil
-      end
-    end
-
     # Receive a message from the Mailbox
     def receive(timeout = nil, &block)
       message = nil
@@ -92,7 +87,6 @@ module Celluloid
         message = @messages.shift
       end
 
-      raise message if message.is_a? SystemEvent
       message
     end
 

data/lib/celluloid/method.rb

@@ -0,0 +1,19 @@
+module Celluloid
+  # Method handles that route through an actor proxy
+  class Method
+    def initialize(actor, name)
+      raise NameError, "undefined method `#{name}'" unless actor.respond_to? name
+
+      @actor, @name = actor, name
+      @klass = @actor.class
+    end
+
+    def call(*args, &block)
+      @actor._send_(@name, *args, &block)
+    end
+
+    def inspect
+      "#<Celluloid::Method #{@klass}#{@name}>"
+    end
+  end
+end

data/lib/celluloid/notifications.rb

@@ -1,5 +1,21 @@
 module Celluloid
   module Notifications
+    def self.notifier
+      Actor[:notifications_fanout] or raise DeadActorError, "notifications fanout actor not running"
+    end
+
+    def publish(pattern, *args)
+      Celluloid::Notifications.notifier.publish(pattern, *args)
+    end
+
+    def subscribe(pattern, method)
+      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
+    end
+
+    def unsubscribe(*args)
+      Celluloid::Notifications.notifier.unsubscribe(*args)
+    end
+
     class Fanout
       include Celluloid
       trap_exit :prune
@@ -63,22 +79,5 @@ module Celluloid
           @pattern && @pattern === subscriber_or_pattern
       end
     end
-
-    class << self
-      attr_accessor :notifier
-    end
-    self.notifier = Fanout.new
-    
-    def publish(pattern, *args)
-      Celluloid::Notifications.notifier.publish(pattern, *args)
-    end
-
-    def subscribe(pattern, method)
-      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
-    end
-
-    def unsubscribe(*args)
-      Celluloid::Notifications.notifier.unsubscribe(*args)
-    end
   end
 end

data/lib/celluloid/pool_manager.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Celluloid
   # Manages a fixed-size pool of workers
   # Delegates work (i.e. methods) and supervises workers
@@ -7,14 +9,28 @@ module Celluloid
     trap_exit :crash_handler
 
     def initialize(worker_class, options = {})
-      @size = options[:size]
-      raise ArgumentError, "minimum pool size is 2" if @size && @size < 2
+      @size = options[:size] || [Celluloid.cores, 2].max
+      raise ArgumentError, "minimum pool size is 2" if @size < 2
 
-      @size ||= [Celluloid.cores, 2].max
+      @worker_class = worker_class
       @args = options[:args] ? Array(options[:args]) : []
 
-      @worker_class = worker_class
       @idle = @size.times.map { worker_class.new_link(*@args) }
+
+      # FIXME: Another data structure (e.g. Set) would be more appropriate
+      # here except it causes MRI to crash :o
+      @busy = []
+    end
+
+    def finalize
+      terminators = (@idle + @busy).each do |actor|
+        begin
+          actor.future(:terminate)
+        rescue DeadActorError, MailboxError
+        end
+      end
+
+      terminators.compact.each { |terminator| terminator.value rescue nil }
     end
 
     def _send_(method, *args, &block)
@@ -22,10 +38,17 @@ module Celluloid
 
       begin
         worker._send_ method, *args, &block
+      rescue DeadActorError # if we get a dead actor out of the pool
+        wait :respawn_complete
+        worker = __provision_worker
+        retry
       rescue Exception => ex
         abort ex
       ensure
-        @idle << worker if worker.alive?
+        if worker.alive?
+          @idle << worker
+          @busy.delete worker
+        end
       end
     end
 
@@ -56,23 +79,29 @@ module Celluloid
     # Provision a new worker
     def __provision_worker
       while @idle.empty?
-        # Using exclusive mode blocks incoming messages, so they don't pile
-        # up as waiting Celluloid::Tasks
-        response = exclusive { receive { |msg| msg.is_a? Response } }
+        # Wait for responses from one of the busy workers
+        response = exclusive { receive { |msg| msg.is_a?(Response) } }
         Thread.current[:actor].handle_message(response)
       end
-      @idle.shift
+
+      worker = @idle.shift
+      @busy << worker
+
+      worker
     end
 
     # Spawn a new worker for every crashed one
     def crash_handler(actor, reason)
+      @busy.delete actor
       @idle.delete actor
-      return unless reason # don't restart workers that exit cleanly
+      return unless reason
+
       @idle << @worker_class.new_link(*@args)
+      signal :respawn_complete
     end
 
     def respond_to?(method)
-      super || (@worker_class ? @worker_class.instance_methods.include?(method.to_sym) : false)
+      super || @worker_class.instance_methods.include?(method.to_sym)
     end
 
     def method_missing(method, *args, &block)

data/lib/celluloid/registry.rb

@@ -3,8 +3,8 @@ require 'thread'
 module Celluloid
   # The Registry allows us to refer to specific actors by human-meaningful names
   class Registry
-    def self.root
-      @root ||= new
+    class << self
+      attr_reader :root
     end
 
     def initialize
@@ -23,7 +23,7 @@ module Celluloid
         @registry[name.to_sym] = actor
       end
 
-      actor.mailbox.system_event NamingRequest.new(name.to_sym)
+      actor.mailbox << NamingRequest.new(name.to_sym)
     end
 
     # Retrieve an actor by name
@@ -38,7 +38,7 @@ module Celluloid
 
     def delete(name)
       @registry_lock.synchronize do
-        @registry[name.to_sym]
+        @registry.delete name.to_sym
       end
     end
 
@@ -48,7 +48,7 @@ module Celluloid
     end
 
     # removes and returns all registered actors as a hash of `name => actor`
-    # can be used in testing to clear the registry 
+    # can be used in testing to clear the registry
     def clear
       hash = nil
       @registry_lock.synchronize do
@@ -57,5 +57,8 @@ module Celluloid
       end
       hash
     end
+
+    # Create the default registry
+    @root = new
   end
 end

data/lib/celluloid/rspec.rb

@@ -1,2 +1,6 @@
+require File.expand_path('../../../spec/support/example_actor_class', __FILE__)
 require File.expand_path('../../../spec/support/actor_examples', __FILE__)
 require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)
+
+# Timer accuracy enforced by the tests (50ms)
+TIMER_QUANTUM = 0.05

data/lib/celluloid/supervision_group.rb

@@ -28,7 +28,7 @@ module Celluloid
           # Take five, toplevel supervisor
           sleep 5 while supervisor.alive?
 
-          Logger.error "!!! Celluloid::Group #{self} crashed. Restarting..."
+          Logger.error "!!! Celluloid::SupervisionGroup #{self} crashed. Restarting..."
         end
       end
 
@@ -44,9 +44,13 @@ module Celluloid
       end
 
       # Register a pool of actors to be launched on group startup
-      def pool(klass)
+      # Available options are:
+      #
+      # * as: register this application in the Celluloid::Actor[] directory
+      # * args: start the actor pool with the given arguments
+      def pool(klass, options = {})
         blocks << lambda do |group|
-          group.pool klass
+          group.pool klass, options
         end
       end
     end
@@ -67,8 +71,9 @@ module Celluloid
       add(klass, :args => args, :block => block, :as => name)
     end
 
-    def pool(klass)
-      add(klass, :method => 'pool_link')
+    def pool(klass, options = {})
+      options[:method] = 'pool_link'
+      add(klass, options)
     end
 
     def add(klass, options)
@@ -106,16 +111,27 @@ module Celluloid
         options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
 
         @name = options['as']
-        @args = options['args'] ? Array(options['args']) : []
         @block = options['block']
+        @args = options['args'] ? Array(options['args']) : []
         @method = options['method'] || 'new_link'
+        @pool = @method == 'pool_link'
+        @pool_size = options['size'] if @pool
 
         start
       end
       attr_reader :name, :actor
 
       def start
-        @actor = @klass.send(@method, *@args, &@block)
+        # when it is a pool, then we don't splat the args
+        # and we need to extract the pool size if set
+        if @pool
+          options = {:args => @args}.tap do |hash|
+            hash[:size] = @pool_size if @pool_size
+          end
+          @actor = @klass.send(@method, options, &@block)
+        else
+          @actor = @klass.send(@method, *@args, &@block)
+        end
         @registry[@name] = @actor if @name
       end
 
@@ -135,7 +151,4 @@ module Celluloid
       end
     end
   end
-
-  # Legacy support for the old name
-  Group = SupervisionGroup
 end