celluloid 0.10.0 → 0.11.0

data/README.md

@@ -72,18 +72,28 @@ for more detailed documentation and usage notes.
 Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
 or visit us on IRC at #celluloid on freenode
 
+### Is it any good?
+
+[Yes.](http://news.ycombinator.com/item?id=3067434)
+
+### Is It "Production Ready™"?
+
+Yes, many users are now running Celluloid in production by using
+[Sidekiq](https://github.com/mperham/sidekiq)
+
 Supported Platforms
 -------------------
 
-Celluloid works on Ruby 1.9.3, JRuby 1.6 (in 1.9 mode), and Rubinius 2.0. JRuby
-or Rubinius are the preferred platforms as they support true hardware-level
-parallelism for Ruby threads, whereas MRI/YARV is constrained by a global
-interpreter lock (GIL) and can only execute one thread at a time.
+Celluloid works on Ruby 1.9.3, JRuby 1.6, and Rubinius 2.0. JRuby or Rubinius
+are the preferred platforms as they support true thread-level parallelism when
+executing Ruby code, whereas MRI/YARV is constrained by a global interpreter
+lock (GIL) and can only execute one thread at a time.
 
-To use JRuby in 1.9 mode, you'll need to pass the "--1.9" command line option
-to the JRuby executable, or set the "JRUBY_OPTS=--1.9" environment variable.
+Celluloid requires Ruby 1.9 mode on all interpreters. This works out of the
+box on MRI/YARV, and requires the following flags elsewhere:
 
-Celluloid works on Rubinius in either 1.8 or 1.9 mode.
+* JRuby: --1.9 command line option, or JRUBY_OPTS=--1.9 environment variable
+* rbx: -X19 command line option
 
 Additional Reading
 ------------------

data/lib/celluloid.rb

@@ -73,8 +73,11 @@ module Celluloid
         actors = Actor.all
         Logger.info "Terminating #{actors.size} actors..." if actors.size > 0
 
+        # Attempt to shut down the supervision tree, if available
+        Supervisor.root.terminate if Supervisor.root
+
         # Actors cannot self-terminate, you must do it for them
-        terminators = actors.each do |actor|
+        terminators = Actor.all.each do |actor|
           begin
             actor.future(:terminate)
           rescue DeadActorError, MailboxError
@@ -130,6 +133,25 @@ module Celluloid
       Supervisor.supervise_as(name, self, *args, &block)
     end
 
+    # Create a new pool of workers. Accepts the following options:
+    #
+    # * size: how many workers to create. Default is worker per CPU core
+    # * args: array of arguments to pass when creating a worker
+    #
+    def pool(options = {})
+      PoolManager.new(self, options)
+    end
+
+    # Same as pool, but links to the pool manager
+    def pool_link(options = {})
+      PoolManager.new_link(self, options)
+    end
+
+    # Run an actor in the foreground
+    def run(*args, &block)
+      new(*args, &block).join
+    end
+
     # Trap errors from actors we're linked to when they exit
     def trap_exit(callback)
       @exit_handler = callback.to_sym
@@ -174,6 +196,11 @@ module Celluloid
 
   # Raise an exception in caller context, but stay running
   def abort(cause)
+    cause = case cause
+      when String then RuntimeError.new(cause)
+      when Exception then cause
+      else raise TypeError, "Exception object/String expected, but #{cause.class} received"
+    end
     raise AbortError.new(cause)
   end
 
@@ -207,6 +234,11 @@ module Celluloid
     Actor.current
   end
 
+  # Obtain the name of the current actor
+  def name
+    Actor.name
+  end
+
   # Obtain the running tasks for this actor
   def tasks
     Thread.current[:actor].tasks.to_a
@@ -280,17 +312,28 @@ module Celluloid
   # messages in its mailbox in the meantime
   def defer(&block)
     # This implementation relies on the present implementation of
-    # Celluloid::Future, which uses an Actor to run the block
+    # Celluloid::Future, which uses a thread from InternalPool to run the block
     Future.new(&block).value
   end
 
+  # Handle async calls within an actor itself
+  def async(meth, *args, &block)
+    Actor.async Thread.current[:actor].mailbox, meth, *args, &block
+  end
+
+  # Handle calls to future within an actor itself
+  def future(meth, *args, &block)
+    Actor.future Thread.current[:actor].mailbox, meth, *args, &block
+  end
+
   # Process async calls via method_missing
   def method_missing(meth, *args, &block)
     # bang methods are async calls
     if meth.to_s.match(/!$/)
       unbanged_meth = meth.to_s.sub(/!$/, '')
-      call = AsyncCall.new(@mailbox, unbanged_meth, args, block)
+      args.unshift unbanged_meth
 
+      call = AsyncCall.new(nil, :__send__, args, block)
       begin
         Thread.current[:actor].mailbox << call
       rescue MailboxError
@@ -315,20 +358,21 @@ require 'celluloid/cpu_counter'
 require 'celluloid/events'
 require 'celluloid/fiber'
 require 'celluloid/fsm'
+require 'celluloid/internal_pool'
 require 'celluloid/links'
 require 'celluloid/logger'
 require 'celluloid/mailbox'
-require 'celluloid/pool'
 require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
 require 'celluloid/signals'
 require 'celluloid/task'
+require 'celluloid/thread_handle'
 require 'celluloid/timers'
-require 'celluloid/thread_pool'
 require 'celluloid/uuid'
 
 require 'celluloid/actor'
 require 'celluloid/future'
-require 'celluloid/group'
+require 'celluloid/pool_manager'
+require 'celluloid/supervision_group'
 require 'celluloid/supervisor'

data/lib/celluloid/actor.rb

@@ -20,7 +20,7 @@ module Celluloid
   # messages.
   class Actor
     extend Registry
-    attr_reader :proxy, :tasks, :links, :mailbox
+    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
 
     class << self
       # Obtain the current actor
@@ -29,7 +29,14 @@ module Celluloid
         raise NotActorError, "not in actor scope" unless actor
         actor.proxy
       end
-      
+
+      # Obtain the name of the current actor
+      def name
+        actor = Thread.current[:actor]
+        raise NotActorError, "not in actor scope" unless actor
+        actor.name
+      end
+
       # Invoke a method on the given actor via its mailbox
       def call(mailbox, meth, *args, &block)
         call = SyncCall.new(Thread.mailbox, meth, args, block)
@@ -87,7 +94,6 @@ module Celluloid
     def initialize(subject)
       @subject   = subject
       @mailbox   = subject.class.mailbox_factory
-      @proxy     = ActorProxy.new(@mailbox, subject.class.to_s)
       @tasks     = Set.new
       @links     = Links.new
       @signals   = Signals.new
@@ -95,12 +101,15 @@ module Celluloid
       @timers    = Timers.new
       @running   = true
       @exclusive = false
+      @name      = nil
 
-      @thread = ThreadPool.get do
+      @thread = ThreadHandle.new do
         Thread.current[:actor]   = self
         Thread.current[:mailbox] = @mailbox
         run
       end
+
+      @proxy = ActorProxy.new(self)
     end
 
     # Is this actor running in exclusive mode?
@@ -145,6 +154,9 @@ module Celluloid
           rescue ExitEvent => exit_event
             Task.new(:exit_handler) { handle_exit_event exit_event }.resume
             retry
+          rescue NamingRequest => ex
+            @name = ex.name
+            retry
           rescue TerminationRequest
             break
           end
@@ -162,8 +174,9 @@ module Celluloid
       end
 
       shutdown
-    rescue => ex
+    rescue Exception => ex
       handle_crash(ex)
+      raise unless ex.is_a? StandardError
     end
 
     # How long to wait until the next timer fires
@@ -249,7 +262,8 @@ module Celluloid
 
     # Run the user-defined finalizer, if one is set
     def run_finalizer
-      @subject.finalize if @subject.respond_to? :finalize
+      return unless @subject.respond_to? :finalize
+      Task.new(:finalizer) { @subject.finalize }.resume
     rescue => ex
       Logger.crash("#{@subject.class}#finalize crashed!", ex)
     end

data/lib/celluloid/actor_proxy.rb

@@ -5,8 +5,8 @@ module Celluloid
   class ActorProxy
     attr_reader :mailbox
 
-    def initialize(mailbox, klass = "Object")
-      @mailbox, @klass = mailbox, klass
+    def initialize(actor)
+      @mailbox, @thread, @klass = actor.mailbox, actor.thread, actor.subject.class.to_s
     end
 
     def _send_(meth, *args, &block)
@@ -17,6 +17,10 @@ module Celluloid
       Actor.call @mailbox, :__send__, :class
     end
 
+    def name
+      Actor.call @mailbox, :name
+    end
+
     def is_a?(klass)
       Actor.call @mailbox, :is_a?, klass
     end
@@ -47,6 +51,12 @@ module Celluloid
       "#<Celluloid::Actor(#{@klass}) dead>"
     end
 
+    # Make an asynchronous call to an actor, for those who don't like the
+    # predicate syntax. TIMTOWTDI!
+    def async(method_name, *args, &block)
+      Actor.async @mailbox, method_name, *args, &block
+    end
+
     # Create a Celluloid::Future which calls a given method
     def future(method_name, *args, &block)
       Actor.future @mailbox, method_name, *args, &block
@@ -64,14 +74,27 @@ module Celluloid
       @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
+    end
+
     # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
-      meth = meth.to_s
-
       # bang methods are async calls
       if meth.match(/!$/)
-        meth.sub!(/!$/, '')
-        Actor.async @mailbox, meth, *args, &block
+        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

data/lib/celluloid/calls.rb

@@ -91,14 +91,14 @@ module Celluloid
       begin
         check_signature(obj)
       rescue Exception => ex
-        Logger.crash("#{obj.class}: async call failed!", ex)
+        Logger.crash("#{obj.class}: async call `#{@method}' failed!", ex)
         return
       end
 
       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 aborted!", ex)
+      Logger.crash("#{obj.class}: async call `#{@method}' aborted!", ex)
     end
   end
 end

data/lib/celluloid/core_ext.rb

@@ -10,11 +10,11 @@ class Thread
   end
 
   # Receive a message either as an actor or through the local mailbox
-  def self.receive(&block)
+  def self.receive(timeout = nil, &block)
     if Celluloid.actor?
-      Celluloid.receive(&block)
+      Celluloid.receive(timeout, &block)
     else
-      mailbox.receive(&block)
+      mailbox.receive(timeout, &block)
     end
   end
 end

data/lib/celluloid/events.rb

@@ -1,17 +1,26 @@
 module Celluloid
   # Exceptional system events which need to be processed out of band
   class SystemEvent < Exception; end
-  
+
   # An actor has exited for the given reason
   class ExitEvent < SystemEvent
     attr_reader :actor, :reason
-    
+
     def initialize(actor, reason = nil)
       @actor, @reason = actor, reason
       super reason.to_s
     end
   end
-  
+
+  # Name an actor at the time it's registered
+  class NamingRequest < SystemEvent
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
   # Request for an actor to terminate
   class TerminationRequest < SystemEvent; end
-end
+end

data/lib/celluloid/fiber.rb

@@ -24,9 +24,8 @@ rescue LoadError => ex
       # Just in case subsequent JRuby releases have broken fibers :/
       raise ex
     end
-  elsif defined? Rubinius
-    # If we're on Rubinius, we can still work in 1.8 mode
-    Fiber = Rubinius::Fiber
+  elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+    raise LoadError, "Celluloid requires Rubinius 1.9 mode. Please pass the -X19 flag."
   else
     raise ex
   end

data/lib/celluloid/future.rb

@@ -13,7 +13,7 @@ module Celluloid
 
       if block
         @call = SyncCall.new(self, :call, args)
-        ThreadPool.get do
+        InternalPool.get do
           begin
             @call.dispatch(block)
           rescue
@@ -36,7 +36,7 @@ module Celluloid
     end
 
     # Obtain the value for this Future
-    def value
+    def value(timeout = nil)
       ready = result = nil
 
       begin
@@ -61,12 +61,16 @@ module Celluloid
       end
 
       unless ready
-        result = Thread.receive do |msg|
+        result = Thread.receive(timeout) do |msg|
           msg.is_a?(Future::Result) && msg.future == self
         end
       end
 
-      result.value
+      if result
+        result.value
+      else
+        raise "Timed out"
+      end
     end
     alias_method :call, :value
 

data/lib/celluloid/{thread_pool.rb → internal_pool.rb}

@@ -2,7 +2,7 @@ require 'thread'
 
 module Celluloid
   # Maintain a thread pool FOR SPEED!!
-  module ThreadPool
+  module InternalPool
     @pool = []
     @mutex = Mutex.new
 
@@ -15,11 +15,13 @@ module Celluloid
       # Get a thread from the pool, running the given block
       def get(&block)
         @mutex.synchronize do
-          if @pool.empty?
-            thread = create
-          else
-            thread = @pool.shift
-          end
+          begin
+            if @pool.empty?
+              thread = create
+            else
+              thread = @pool.shift
+            end
+          end until thread.status # handle crashed threads
 
           thread[:queue] << block
           thread

data/lib/celluloid/links.rb

@@ -1,50 +1,32 @@
 require 'thread'
 
 module Celluloid
-  # Thread safe storage of inter-actor links
+  # Linked actors send each other system events
   class Links
     include Enumerable
 
     def initialize
       @links = {}
-      @lock  = Mutex.new
     end
 
     # Add an actor to the current links
     def <<(actor)
-      @lock.synchronize do
-        @links[actor.mailbox.address] = actor
-      end
-      actor
+      @links[actor.mailbox.address] = actor
     end
 
     # Do links include the given actor?
     def include?(actor)
-      @lock.synchronize do
-        @links.has_key? actor.mailbox.address
-      end
+      @links.has_key? actor.mailbox.address
     end
 
     # Remove an actor from the links
     def delete(actor)
-      @lock.synchronize do
-        @links.delete actor.mailbox.address
-      end
-      actor
+      @links.delete actor.mailbox.address
     end
 
     # Iterate through all links
     def each
-      @lock.synchronize do
-        @links.each { |_, actor| yield(actor) }
-      end
-    end
-
-    # Map across links
-    def map
-      result = []
-      each { |actor| result << yield(actor) }
-      result
+      @links.each { |_, actor| yield(actor) }
     end
 
     # Send an event message to all actors

data/lib/celluloid/pool_manager.rb

@@ -0,0 +1,62 @@
+module Celluloid
+  # Manages a fixed-size pool of workers
+  # Delegates work (i.e. methods) and supervises workers
+  class PoolManager
+    include 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 ||= [Celluloid.cores, 2].max
+      @args = options[:args] ? Array(options[:args]) : []
+
+      @worker_class = worker_class
+      @idle = @size.times.map { worker_class.new_link(*@args) }
+    end
+
+    # Execute the given method within a worker
+    def execute(method, *args, &block)
+      worker = provision_worker
+
+      begin
+        worker._send_ method, *args, &block
+      rescue => ex
+        abort ex
+      ensure
+        @idle << worker if worker.alive?
+      end
+    end
+
+    # 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 } }
+        Thread.current[:actor].handle_message(response)
+      end
+      @idle.shift
+    end
+
+    # Spawn a new worker for every crashed one
+    def crash_handler(actor, reason)
+      @idle.delete actor
+      return unless reason # don't restart workers that exit cleanly
+      @idle << @worker_class.new_link(*@args)
+    end
+
+    def respond_to?(method)
+      super || (@worker_class ? @worker_class.instance_methods.include?(method.to_sym) : false)
+    end
+
+    def method_missing(method, *args, &block)
+      if respond_to?(method)
+        execute method, *args, &block
+      else
+        super
+      end
+    end
+  end
+end

data/lib/celluloid/registry.rb

@@ -16,6 +16,8 @@ module Celluloid
       @@registry_lock.synchronize do
         @@registry[name.to_sym] = actor
       end
+
+      actor.mailbox.system_event NamingRequest.new(name.to_sym)
     end
 
     # Retrieve an actor by name

data/lib/celluloid/supervision_group.rb

@@ -0,0 +1,99 @@
+module Celluloid
+  # Supervise collections of actors as a group
+  class SupervisionGroup
+    include Celluloid
+    trap_exit :restart_actor
+
+    class << self
+      # Actors or sub-applications to be supervised
+      def members
+        @members ||= []
+      end
+
+      # Start this application (and watch it with a supervisor)
+      alias_method :run!, :supervise
+
+      # Run the application in the foreground with a simple watchdog
+      def run
+        loop do
+          supervisor = run!
+
+          # Take five, toplevel supervisor
+          sleep 5 while supervisor.alive?
+
+          Logger.error "!!! Celluloid::Group #{self} crashed. Restarting..."
+        end
+      end
+
+      # Register an actor class or a sub-group to be launched and supervised
+      # Available options are:
+      #
+      # * as: register this application in the Celluloid::Actor[] directory
+      # * args: start the actor with the given arguments
+      def supervise(klass, options = {})
+        members << Member.new(klass, options)
+      end
+
+      # Register a pool of actors to be launched on group startup
+      def pool(klass)
+        members << Member.new(klass, method: 'pool_link')
+      end
+    end
+
+    # Start the group
+    def initialize
+      @actors = {}
+
+      # This is some serious lolcode, but like... start the supervisors for
+      # this group
+      self.class.members.each do |member|
+        actor = member.start
+        @actors[actor] = member
+      end
+    end
+
+    # Terminate the group
+    def finalize
+      @actors.each do |actor, _|
+        begin
+          actor.terminate
+        rescue DeadActorError
+        end
+      end
+    end
+
+    # Restart a crashed actor
+    def restart_actor(actor, reason)
+      member = @actors.delete actor
+      raise "a group member went missing. This shouldn't be!" unless member
+
+      # Ignore supervisors that shut down cleanly
+      return unless reason
+
+      actor = member.start
+      @actors[actor] = member
+    end
+
+    # A member of the group
+    class Member
+      def initialize(klass, options = {})
+        @klass = klass
+
+        # Stringify keys :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+
+        @name = options['as']
+        @args = options['args'] ? Array(options['args']) : []
+        @method = options['method'] || 'new_link'
+      end
+
+      def start
+        actor = @klass.send(@method, *@args)
+        Actor[@name] = actor if @name
+      end
+    end
+  end
+
+  # Legacy support for the old name
+  Group = SupervisionGroup
+end

data/lib/celluloid/supervisor.rb

@@ -8,12 +8,17 @@ module Celluloid
     # Retrieve the actor this supervisor is supervising
     attr_reader :actor
 
-    def self.supervise(klass, *args, &block)
-      new(nil, klass, *args, &block)
-    end
+    class << self
+      # Define the root of the supervision tree
+      attr_accessor :root
+
+      def supervise(klass, *args, &block)
+        new(nil, klass, *args, &block)
+      end
 
-    def self.supervise_as(name, klass, *args, &block)
-      new(name, klass, *args, &block)
+      def supervise_as(name, klass, *args, &block)
+        new(name, klass, *args, &block)
+      end
     end
 
     def initialize(name, klass, *args, &block)
@@ -23,6 +28,10 @@ module Celluloid
       start_actor
     end
 
+    def finalize
+      @actor.terminate if @actor and @actor.alive?
+    end
+
     def start_actor(start_attempts = 3, sleep_interval = 30)
       failures = 0
 

data/lib/celluloid/task.rb

@@ -46,6 +46,7 @@ module Celluloid
         rescue TerminatedError
           # Task was explicitly terminated
         ensure
+          @status = :dead
           actor.tasks.delete self
         end
       end
@@ -57,10 +58,6 @@ module Celluloid
       nil
     rescue FiberError
       raise DeadTaskError, "cannot resume a dead task"
-    rescue RuntimeError => ex
-      # These occur spuriously on 1.9.3 if we shut down an actor with running tasks
-      return if ex.message == ""
-      raise
     end
 
     # Terminate this task

data/lib/celluloid/thread_handle.rb

@@ -0,0 +1,38 @@
+module Celluloid
+  # An abstraction around threads from the InternalPool which ensures we don't
+  # accidentally do things to threads which have been returned to the pool,
+  # such as, say, killing them
+  class ThreadHandle
+    def initialize
+      @mutex = Mutex.new
+      @join  = ConditionVariable.new
+
+      @thread = InternalPool.get do
+        begin
+          yield
+        ensure
+          @mutex.synchronize do
+            @thread = nil
+            @join.broadcast
+          end
+        end
+      end
+    end
+
+    # Is the thread running?
+    def alive?
+      @mutex.synchronize { @thread.alive? if @thread }
+    end
+
+    # Forcibly kill the thread
+    def kill
+      !!@mutex.synchronize { @thread.kill if @thread }
+    end
+
+    # Join to a running thread, blocking until it terminates
+    def join
+      @mutex.synchronize { @join.wait(@mutex) if @thread }
+      nil
+    end
+  end
+end

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.10.0'
+  VERSION = '0.11.0'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -39,6 +39,10 @@ shared_context "a Celluloid Actor" do |included_module|
         abort example_crash
       end
 
+      def crash_with_abort_raw(reason)
+        abort reason
+      end
+
       def internal_hello
         external_hello
       end
@@ -59,6 +63,16 @@ shared_context "a Celluloid Actor" do |included_module|
         super || delegates?(method_name)
       end
 
+      def call_private
+        zomg_private!
+      end
+
+      def zomg_private
+        @private_called = true
+      end
+      private :zomg_private
+      attr_reader :private_called
+
       private
 
       def delegates?(method_name)
@@ -132,25 +146,44 @@ shared_context "a Celluloid Actor" do |included_module|
     end.to raise_exception(ExampleCrash)
   end
 
-  it "raises exceptions in the caller when abort is called, but keeps running" do
-    actor = actor_class.new "Al Pacino"
+  describe "when #abort is called" do
+    it "raises exceptions in the caller but keeps running" do
+      actor = actor_class.new "Al Pacino"
 
-    e = nil
-    line_no = nil
+      e = nil
+      line_no = nil
 
-    expect do
-      begin
-        line_no = __LINE__; actor.crash_with_abort "You die motherfucker!", :bar
-      rescue => ex
-        e = ex
-        raise
-      end
-    end.to raise_exception(ExampleCrash, "You die motherfucker!")
+      expect do
+        begin
+          line_no = __LINE__; actor.crash_with_abort "You die motherfucker!", :bar
+        rescue => ex
+          e = ex
+          raise
+        end
+      end.to raise_exception(ExampleCrash, "You die motherfucker!")
+
+      e.backtrace.any? { |line| line.include?([__FILE__, line_no].join(':')) }.should be_true # Check the backtrace is appropriate to the caller
+      e.foo.should be == :bar # Check the exception maintains instance variables
+
+      actor.should be_alive
+    end
 
-    e.backtrace.any? { |line| line.include?([__FILE__, line_no].join(':')) }.should be_true # Check the backtrace is appropriate to the caller
-    e.foo.should be == :bar # Check the exception maintains instance variables
+    it "converts strings to runtime errors" do
+      actor = actor_class.new "Al Pacino"
+      expect do
+        actor.crash_with_abort_raw "foo"
+      end.to raise_exception(RuntimeError, "foo")
+    end
 
-    actor.should be_alive
+    it "crashes the caller if we pass neither String nor Exception" do
+      actor = actor_class.new "Al Pacino"
+      expect do
+        actor.crash_with_abort_raw 10
+      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
+
+      actor.greet rescue nil # Ensure our actor has died.
+      actor.should_not be_alive
+    end
   end
 
   it "raises DeadActorError if methods are synchronously called on a dead actor" do
@@ -168,12 +201,24 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.greet.should == "Hi, I'm Charlie Sheen"
   end
 
+  it "handles asynchronous calls via #async" do
+    actor = actor_class.new "Troy McClure"
+    actor.async :change_name, "Charlie Sheen"
+    actor.greet.should == "Hi, I'm Charlie Sheen"
+  end
+
   it "handles asynchronous calls to itself" do
     actor = actor_class.new "Troy McClure"
     actor.change_name_async "Charlie Sheen"
     actor.greet.should == "Hi, I'm Charlie Sheen"
   end
 
+  it "allows an actor to call private methods asynchronously with a bang" do
+    actor = actor_class.new "Troy McClure"
+    actor.call_private
+    actor.private_called.should be_true
+  end
+
   it "knows if it's inside actor scope" do
     Celluloid.should_not be_actor
     actor = actor_class.new "Troy McClure"
@@ -224,7 +269,15 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = actor_class.new "Arnold Schwarzenegger"
       actor.should be_alive
       actor.terminate
-      sleep 0.5 # hax
+      actor.join
+      actor.should_not be_alive
+    end
+
+    it "kills" do
+      actor = actor_class.new "Woody Harrelson"
+      actor.should be_alive
+      actor.kill
+      actor.join
       actor.should_not be_alive
     end
 
@@ -388,7 +441,7 @@ shared_context "a Celluloid Actor" do |included_module|
       received_obj.should == message
     end
 
-    it "times out after the given interval" do
+    it "times out after the given interval", :pending => ENV['CI'] do
       interval = 0.1
       started_at = Time.now
 
@@ -520,10 +573,8 @@ shared_context "a Celluloid Actor" do |included_module|
     it "knows which tasks are waiting on calls to other actors" do
       actor = @klass.new
 
-      # an alias for Celluloid::Actor#waiting_tasks
       tasks = actor.tasks
       tasks.size.should == 1
-      tasks.first.status.should == :running
 
       future = actor.future(:blocking_call)
       sleep 0.1 # hax! waiting for ^^^ call to actually start

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-02 00:00:00.000000000 Z
+date: 2012-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70363787045800 !ruby/object:Gem::Requirement
+  requirement: &70191377653480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70363787045800
+  version_requirements: *70191377653480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70363787045200 !ruby/object:Gem::Requirement
+  requirement: &70191377602840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70363787045200
+  version_requirements: *70191377602840
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70363787044600 !ruby/object:Gem::Requirement
+  requirement: &70191350440520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70363787044600
+  version_requirements: *70191350440520
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
-  requirement: &70363787044060 !ruby/object:Gem::Requirement
+  requirement: &70191350401720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70363787044060
+  version_requirements: *70191350401720
 description: Celluloid enables people to build concurrent programs out of concurrent
   objects just as easily as they build sequential programs out of sequential objects
 email:
@@ -73,19 +73,20 @@ files:
 - lib/celluloid/fiber.rb
 - lib/celluloid/fsm.rb
 - lib/celluloid/future.rb
-- lib/celluloid/group.rb
+- lib/celluloid/internal_pool.rb
 - lib/celluloid/links.rb
 - lib/celluloid/logger.rb
 - lib/celluloid/mailbox.rb
-- lib/celluloid/pool.rb
+- lib/celluloid/pool_manager.rb
 - lib/celluloid/receivers.rb
 - lib/celluloid/registry.rb
 - lib/celluloid/responses.rb
 - lib/celluloid/rspec.rb
 - lib/celluloid/signals.rb
+- lib/celluloid/supervision_group.rb
 - lib/celluloid/supervisor.rb
 - lib/celluloid/task.rb
-- lib/celluloid/thread_pool.rb
+- lib/celluloid/thread_handle.rb
 - lib/celluloid/timers.rb
 - lib/celluloid/uuid.rb
 - lib/celluloid/version.rb
@@ -113,8 +114,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Actor-based concurrent object framework for Ruby
 test_files: []
+has_rdoc: 

data/lib/celluloid/group.rb

@@ -1,85 +0,0 @@
-module Celluloid
-  # Supervise collections of actors as a group
-  class Group
-    include Celluloid
-    trap_exit :restart_supervisor
-
-    class << self
-      # Actors or sub-applications to be supervised
-      def supervisables
-        @supervisables ||= []
-      end
-
-      # Start this application (and watch it with a supervisor)
-      alias_method :run!, :supervise
-
-      # Run the application in the foreground with a simple watchdog
-      def run
-        loop do
-          supervisor = run!
-
-          # Take five, toplevel supervisor
-          sleep 5 while supervisor.alive?
-
-          Logger.error "!!! Celluloid::Application #{self} crashed. Restarting..."
-        end
-      end
-
-      # Register an actor class or a sub-application class to be launched and
-      # supervised while this application is running. Available options are:
-      #
-      # * as: register this application in the Celluloid::Actor[] directory
-      # * args: start the actor with the given arguments
-      def supervise(klass, options = {})
-        supervisables << Supervisable.new(klass, options)
-      end
-    end
-
-    # Start the application
-    def initialize
-      @supervisors = {}
-
-      # This is some serious lolcode, but like... start the supervisors for
-      # this application
-      self.class.supervisables.each do |supervisable|
-        supervisor = supervisable.supervise
-        @supervisors[supervisor] = supervisable
-      end
-    end
-
-    # Restart a crashed supervisor
-    def restart_supervisor(supervisor, reason)
-      supervisable = @supervisors.delete supervisor
-      raise "a supervisable went missing. This shouldn't be!" unless supervisable
-
-      # Ignore supervisors that shut down cleanly
-      return unless reason
-
-      supervisor = supervisable.supervise
-      @supervisors[supervisor] = supervisable
-    end
-
-    # A subcomponent of an application to be supervised
-    class Supervisable
-      attr_reader :klass, :as, :args
-
-      def initialize(klass, options = {})
-        @klass = klass
-
-        # Stringify keys :/
-        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-
-        @as = options['as']
-        @args = options['args'] || []
-        raise ":args should be an Array" unless @args.kind_of? Array
-      end
-
-      def supervise
-        Supervisor.new_link(@as, @klass, *@args)
-      end
-    end
-  end
-
-  # Legacy support for the old name. Going away soon!
-  Application = Group
-end

data/lib/celluloid/pool.rb

@@ -1,105 +0,0 @@
-module Celluloid
-  # Pools provide groups of actors which can service requests
-  class Pool
-    include Celluloid
-    trap_exit :crash_handler
-    attr_reader :max_actors
-
-    # Takes a class of actor to pool and a hash of options:
-    #
-    # * initial_size: how many actors to eagerly create
-    # * max_size: maximum number of actors (default one actor per CPU core)
-    # * args: an array of arguments to pass to the actor's initialize
-    def initialize(klass, options = {})
-      raise ArgumentError, "A Pool has a minimum size of 2" if options[:max_size] && options[:max_size] < 2
-      opts = {
-        :initial_size => 1,
-        :max_size     => [Celluloid.cores, 2].max,
-        :args         => []
-      }.merge(options)
-
-      @klass, @args = klass, opts[:args]
-      @max_actors = opts[:max_size]
-      @idle_actors, @running_actors = 0, 0
-      @actors = []
-
-      opts[:initial_size].times do
-        @actors << spawn
-        @idle_actors += 1
-      end
-    end
-
-    # Get an actor from the pool. Actors taken from the pool must be put back
-    # with Pool#put. Alternatively, you can use get with a block form:
-    #
-    #     pool.get { |actor| ... }
-    #
-    # This will automatically return actors to the pool when the block completes
-    def get
-      if @max_actors and @running_actors == @max_actors
-        wait :ready
-      end
-
-      actor = @actors.pop
-      if actor
-        @idle_actors -= 1
-      else
-        actor = spawn
-      end
-
-      if block_given?
-        begin
-          yield actor
-        rescue => ex
-        end
-
-        put actor
-        abort ex if ex
-        nil
-      else
-        actor
-      end
-    end
-
-    # Return an actor to the pool
-    def put(actor)
-      begin
-        raise TypeError, "expecting a #{@klass} actor" unless actor.is_a? @klass
-      rescue DeadActorError
-        # The actor may have died before it was handed back to us
-        # We'll let the crash_handler deal with it in due time
-        return
-      end
-
-      @actors << actor
-      @idle_actors += 1
-    end
-
-    # Number of active actors in this pool
-    def size
-      @running_actors
-    end
-
-    # Number of idle actors in the pool
-    def idle_count
-      @idle_actors
-    end
-    alias_method :idle_size, :idle_count
-
-    # Handle crashed actors
-    def crash_handler(actor, reason)
-      @idle_actors    -= 1 if @actors.delete actor
-      @running_actors -= 1
-
-      # If we were maxed out before...
-      signal :ready if @max_actors and @running_actors + 1 == @max_actors
-    end
-
-    # Spawn an actor of the given class
-    def spawn
-      worker = @klass.new_link(*@args)
-      @running_actors += 1
-      worker
-    end
-  end
-end