celluloid 0.8.0 → 0.9.0

data/README.md

@@ -1,6 +1,7 @@
-Celluloid
+![Celluloid](https://github.com/tarcieri/celluloid/raw/master/logo.png)
 =========
-[![Build Status](http://travis-ci.org/tarcieri/celluloid.png)](http://travis-ci.org/tarcieri/celluloid) [![Dependency Status](https://gemnasium.com/tarcieri/celluloid.png)](https://gemnasium.com/tarcieri/celluloid)
+[![Build Status](https://secure.travis-ci.org/tarcieri/celluloid.png?branch=master)](http://travis-ci.org/tarcieri/celluloid)
+[![Dependency Status](https://gemnasium.com/tarcieri/celluloid.png)](https://gemnasium.com/tarcieri/celluloid)
 
 > "I thought of objects being like biological cells and/or individual
 > computers on a network, only able to communicate with messages"
@@ -137,12 +138,18 @@ and [linking](https://github.com/tarcieri/celluloid/wiki/linking)
 [Please see the Celluloid Wiki](https://github.com/tarcieri/celluloid/wiki)
 for additional usage information.
 
+Suggested Reading
+-----------------
+
+* [Concurrent Object-Oriented Programming in Python with ATOM](http://python.org/workshops/1997-10/proceedings/atom/)
+
 Contributing to Celluloid
 -------------------------
 
-* Fork Celluloid on github
+* Fork this repository on github
 * Make your changes and send me a pull request
-* If I like them I'll merge them and give you commit access to my repository
+* If I like them I'll merge them
+* If I've accepted a patch, feel free to ask for commit access
 
 License
 -------

data/lib/celluloid.rb

@@ -1,7 +1,9 @@
 require 'logger'
 require 'thread'
+require 'timeout'
 
 module Celluloid
+  SHUTDOWN_TIMEOUT = 60 # How long actors have to terminate
   @logger = Logger.new STDERR
 
   class << self
@@ -16,6 +18,11 @@ module Celluloid
       !!Thread.current[:actor]
     end
 
+    # Is current actor running in exclusive mode?
+    def exclusive?
+      actor? and Thread.current[:actor].exclusive?
+    end
+
     # Obtain the currently running actor (if one exists)
     def current_actor
       actor = Thread.current[:actor]
@@ -43,14 +50,43 @@ module Celluloid
         Kernel.sleep interval
       end
     end
+
+    # Define an exception handler for actor crashes
+    def exception_handler(&block)
+      Logger.exception_handler(&block)
+    end
+
+    # Shut down all running actors
+    # FIXME: This should probably attempt a graceful shutdown of the supervision
+    # tree before iterating through all actors and telling them to terminate.
+    def shutdown
+      Timeout.timeout(SHUTDOWN_TIMEOUT) do
+        futures = Actor.all.each do |actor|
+          begin
+            actor.future(:terminate)
+          rescue DeadActorError, MailboxError
+          end
+        end
+
+        futures.each do |future|
+          begin
+            future.value
+          rescue DeadActorError, MailboxError
+          end
+        end
+      end
+    end
   end
 
+  # Terminate all actors at exit
+  at_exit { shutdown }
+
   # Class methods added to classes which include Celluloid
   module ClassMethods
     # Create a new actor
     def new(*args, &block)
       proxy = Actor.new(allocate).proxy
-      proxy.send(:initialize, *args, &block)
+      proxy.send(:__send__, :initialize, *args, &block)
       proxy
     end
     alias_method :spawn, :new
@@ -62,7 +98,7 @@ module Celluloid
 
       proxy = Actor.new(allocate).proxy
       current_actor.link proxy
-      proxy.send(:initialize, *args, &block)
+      proxy.send(:__send__, :initialize, *args, &block)
       proxy
     end
     alias_method :spawn_link, :new_link
@@ -90,11 +126,26 @@ module Celluloid
     # Configure a custom mailbox factory
     def use_mailbox(klass = nil, &block)
       if block
-        define_method(:mailbox_factory, &block)
+        @mailbox_factory = block
+      else
+        @mailbox_factory = proc { klass.new }
+      end
+    end
+
+    # Create a mailbox for this actor
+    def mailbox_factory
+      if defined?(@mailbox_factory)
+        @mailbox_factory.call
+      elsif defined?(super)
+        super
       else
-        define_method(:mailbox_factory) { klass.new }
+        Mailbox.new
       end
     end
+
+    def ===(other)
+      other.kind_of? self
+    end
   end
 
   #
@@ -193,7 +244,13 @@ module Celluloid
     Celluloid.sleep(interval)
   end
 
-  # Call a block after a given interval
+  # Run given block in an exclusive mode: all synchronous calls block the whole
+  # actor, not only current message processing.
+  def exclusive(&block)
+    Thread.current[:actor].exclusive(&block)
+  end
+
+  # Call a block after a given interval, returning a Celluloid::Timer object
   def after(interval, &block)
     Thread.current[:actor].after(interval, &block)
   end
@@ -207,11 +264,6 @@ module Celluloid
     Future.new(&block).value
   end
 
-  # Deprecated, do not use
-  def async
-    raise "Celluloid#async is defunct. Please use #defer instead"
-  end
-
   # Process async calls via method_missing
   def method_missing(meth, *args, &block)
     # bang methods are async calls
@@ -245,6 +297,7 @@ require 'celluloid/fsm'
 require 'celluloid/links'
 require 'celluloid/logger'
 require 'celluloid/mailbox'
+require 'celluloid/pool'
 require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'

data/lib/celluloid/actor.rb

@@ -22,58 +22,64 @@ module Celluloid
     extend Registry
     attr_reader :proxy, :tasks, :links, :mailbox
 
-    # Invoke a method on the given actor via its mailbox
-    def self.call(mailbox, meth, *args, &block)
-      call = SyncCall.new(Thread.mailbox, meth, args, block)
+    class << self
+      # Invoke a method on the given actor via its mailbox
+      def call(mailbox, meth, *args, &block)
+        call = SyncCall.new(Thread.mailbox, meth, args, block)
 
-      begin
-        mailbox << call
-      rescue MailboxError
-        raise DeadActorError, "attempted to call a dead actor"
-      end
+        begin
+          mailbox << call
+        rescue MailboxError
+          raise DeadActorError, "attempted to call a dead actor"
+        end
 
-      if Celluloid.actor?
-        # The current task will be automatically resumed when we get a response
-        Task.suspend :callwait
-      else
-        # Otherwise we're inside a normal thread, so block
-        response = Thread.mailbox.receive do |msg|
-          msg.respond_to?(:call) and msg.call == call
+        if Celluloid.actor? and not Celluloid.exclusive?
+          # The current task will be automatically resumed when we get a response
+          Task.suspend(:callwait).value
+        else
+          # Otherwise we're inside a normal thread, so block
+          response = Thread.mailbox.receive do |msg|
+            msg.respond_to?(:call) and msg.call == call
+          end
+
+          response.value
         end
+      end
 
-        response.value
+      # Invoke a method asynchronously on an actor via its mailbox
+      def async(mailbox, meth, *args, &block)
+        begin
+          mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
+        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
       end
-    end
 
-    # Invoke a method asynchronously on an actor via its mailbox
-    def self.async(mailbox, meth, *args, &block)
-      begin
-        mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
-      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)
+      # Call a method asynchronously and retrieve its value later
+      def future(mailbox, meth, *args, &block)
+        future = Future.new
+        future.execute(mailbox, meth, args, block)
+        future
       end
-    end
 
-    # Call a method asynchronously and retrieve its value later
-    def self.future(mailbox, meth, *args, &block)
-      future = Future.new
-      future.execute(mailbox, meth, args, block)
-      future
+      # Obtain all running actors in the system
+      def all
+        actors = []
+        Thread.list.each do |t|
+          actor = t[:actor]
+          actors << actor.proxy if actor
+        end
+        actors
+      end
     end
 
     # Wrap the given subject with an Actor
     def initialize(subject)
-      @subject = subject
-
-      if subject.respond_to? :mailbox_factory
-        @mailbox = subject.mailbox_factory
-      else
-        @mailbox = Mailbox.new
-      end
-
+      @subject   = subject
+      @mailbox   = subject.class.mailbox_factory
       @proxy     = ActorProxy.new(@mailbox, subject.class.to_s)
       @tasks     = Set.new
       @links     = Links.new
@@ -81,11 +87,11 @@ module Celluloid
       @receivers = Receivers.new
       @timers    = Timers.new
       @running   = true
+      @exclusive = false
 
       @thread = ThreadPool.get do
         Thread.current[:actor]   = self
         Thread.current[:mailbox] = @mailbox
-
         run
       end
     end
@@ -95,6 +101,19 @@ module Celluloid
       @running
     end
 
+    # Is this actor running in exclusive mode?
+    def exclusive?
+      @exclusive
+    end
+
+    # Execute a code block in exclusive mode.
+    def exclusive
+      @exclusive = true
+      yield
+    ensure
+      @exclusive = false
+    end
+
     # Terminate this actor
     def terminate
       @running = false
@@ -118,32 +137,30 @@ module Celluloid
 
     # Run the actor loop
     def run
-      while @running
-        begin
-          message = @mailbox.receive(timeout)
-        rescue ExitEvent => exit_event
-          Task.new(:exit_handler) { handle_exit_event exit_event }.resume
-          retry
-        end
-
-        if message
-          handle_message message
-        else
-          # No message indicates a timeout
-          @timers.fire
-          @receivers.fire_timers
+      begin
+        while @running
+          begin
+            message = @mailbox.receive(timeout)
+          rescue ExitEvent => exit_event
+            Task.new(:exit_handler) { handle_exit_event exit_event }.resume
+            retry
+          end
+
+          if message
+            handle_message message
+          else
+            # No message indicates a timeout
+            @timers.fire
+            @receivers.fire_timers
+          end
         end
+      rescue MailboxShutdown
+        # If the mailbox detects shutdown, exit the actor
       end
 
-      cleanup ExitEvent.new(@proxy)
-    rescue MailboxShutdown
-      # If the mailbox detects shutdown, exit the actor
-      @running = false
-    rescue Exception => ex
-      @running = false
+      shutdown
+    rescue => ex
       handle_crash(ex)
-    ensure
-      ThreadPool.put @thread
     end
 
     # How long to wait until the next timer fires
@@ -169,9 +186,13 @@ module Celluloid
 
     # Sleep for the given amount of time
     def sleep(interval)
-      task = Task.current
-      @timers.add(interval) { task.resume }
-      Task.suspend :sleeping
+      if Celluloid.exclusive?
+        Kernel.sleep(interval)
+      else
+        task = Task.current
+        @timers.add(interval) { task.resume }
+        Task.suspend :sleeping
+      end
     end
 
     # Handle an incoming message
@@ -180,7 +201,7 @@ module Celluloid
       when Call
         Task.new(:message_handler) { message.dispatch(@subject) }.resume
       when Response
-        message.call.task.resume message.value
+        message.call.task.resume message
       else
         @receivers.handle_message(message)
       end
@@ -202,22 +223,34 @@ module Celluloid
     # Handle any exceptions that occur within a running actor
     def handle_crash(exception)
       Logger.crash("#{@subject.class} crashed!", exception)
-      cleanup ExitEvent.new(@proxy, exception)
-    rescue Exception => ex
+      shutdown ExitEvent.new(@proxy, exception)
+    rescue => ex
       Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
     end
 
     # Handle cleaning up this actor after it exits
+    def shutdown(exit_event = ExitEvent.new(@proxy))
+      run_finalizer
+      cleanup exit_event
+    ensure
+      Thread.current[:actor]   = nil
+      Thread.current[:mailbox] = nil
+    end
+
+    # Run the user-defined finalizer, if one is set
+    def run_finalizer
+      @subject.finalize if @subject.respond_to? :finalize
+    rescue => ex
+      Logger.crash("#{@subject.class}#finalize crashed!", ex)
+    end
+
+    # Clean up after this actor
     def cleanup(exit_event)
       @mailbox.shutdown
       @links.send_event exit_event
       tasks.each { |task| task.terminate }
-
-      begin
-        @subject.finalize if @subject.respond_to? :finalize
-      rescue Exception => ex
-        Logger.crash("#{@subject.class}#finalize crashed!", ex)
-      end
+    rescue => ex
+      Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
     end
   end
 end

data/lib/celluloid/actor_proxy.rb

@@ -17,6 +17,14 @@ module Celluloid
       Actor.call @mailbox, :send, :class
     end
 
+    def is_a?(klass)
+      Actor.call @mailbox, :is_a?, klass
+    end
+
+    def kind_of?(klass)
+      Actor.call @mailbox, :kind_of?, klass
+    end
+
     def respond_to?(meth)
       Actor.call @mailbox, :respond_to?, meth
     end

data/lib/celluloid/future.rb

@@ -18,8 +18,6 @@ module Celluloid
             @call.dispatch(block)
           rescue
             # Exceptions in blocks will get raised when the value is retrieved
-          ensure
-            ThreadPool.put Thread.current
           end
         end
       else

data/lib/celluloid/group.rb

@@ -52,6 +52,9 @@ module Celluloid
       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

data/lib/celluloid/logger.rb

@@ -1,5 +1,6 @@
 module Celluloid
   module Logger
+    @exception_handlers = []
     module_function
 
     # Send a debug message
@@ -24,9 +25,29 @@ module Celluloid
 
     # Handle a crash
     def crash(string, exception)
-      string += "\n#{exception.class}: #{exception.to_s}\n"
-      string << exception.backtrace.join("\n")
-      error(string)
+      string << "\n" << format_exception(exception)
+      error string
+
+      @exception_handlers.each do |handler|
+        begin
+          handler.call(exception)
+        rescue => ex
+          error "EXCEPTION HANDLER CRASHED:\n" << format_exception(ex)
+        end
+      end
+    end
+
+    # Format an exception message
+    def format_exception(exception)
+      str = "#{exception.class}: #{exception.to_s}\n"
+      str << exception.backtrace.join("\n")
+    end
+
+    # Define an exception handler
+    # NOTE: These should be defined at application start time
+    def exception_handler(&block)
+      @exception_handlers << block
+      nil
     end
   end
 end

data/lib/celluloid/mailbox.rb

@@ -14,59 +14,65 @@ module Celluloid
 
     def initialize
       @messages = []
-      @lock  = Mutex.new
+      @mutex = Mutex.new
       @dead = false
       @condition = ConditionVariable.new
     end
 
     # Add a message to the Mailbox
     def <<(message)
-      @lock.lock
-      raise MailboxError, "dead recipient" if @dead
+      @mutex.lock
+      begin
+        raise MailboxError, "dead recipient" if @dead
 
-      @messages << message
-      @condition.signal
-      nil
-    ensure @lock.unlock
+        @messages << message
+        @condition.signal
+        nil
+      ensure @mutex.unlock
+      end
     end
 
     # Add a high-priority system event to the Mailbox
     def system_event(event)
-      @lock.lock
-      unless @dead # Silently fail if messages are sent to dead actors
-        @messages.unshift event
-        @condition.signal
+      @mutex.lock
+      begin
+        unless @dead # Silently fail if messages are sent to dead actors
+          @messages.unshift event
+          @condition.signal
+        end
+        nil
+      ensure @mutex.unlock
       end
-      nil
-    ensure @lock.unlock
     end
 
     # Receive a message from the Mailbox
     def receive(timeout = nil, &block)
       message = nil
 
-      @lock.lock
-      raise MailboxError, "attempted to receive from a dead mailbox" if @dead
-
+      @mutex.lock
       begin
-        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
+        raise MailboxError, "attempted to receive from a dead mailbox" if @dead
+
+        begin
+          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
 
-          @condition.wait(@lock, wait_interval)
-        end
-      end until message
-
-      message
-    ensure @lock.unlock
+        message
+      ensure @mutex.unlock
+      end
     end
 
     # Retrieve the next message in the mailbox
@@ -89,16 +95,16 @@ module Celluloid
 
     # Shut down this mailbox and clean up its contents
     def shutdown
-      messages = nil
-
-      @lock.lock
-      messages = @messages
-      @messages = []
-      @dead = true
+      @mutex.lock
+      begin
+        messages = @messages
+        @messages = []
+        @dead = true
+      ensure @mutex.unlock
+      end
 
       messages.each { |msg| msg.cleanup if msg.respond_to? :cleanup }
       true
-    ensure @lock.unlock
     end
 
     # Is the mailbox alive?
@@ -108,9 +114,7 @@ module Celluloid
 
     # Cast to an array
     def to_a
-      @lock.lock
-      @messages.dup
-    ensure @lock.unlock
+      @mutex.synchronize { @messages.dup }
     end
 
     # Iterate through the mailbox

data/lib/celluloid/pool.rb

@@ -0,0 +1,103 @@
+module Celluloid
+  # Pools provide groups of actors which can service requests
+  class Pool
+    include Celluloid
+    trap_exit :crash_handler
+
+    # 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 nil, unlimited)
+    # * args: an array of arguments to pass to the actor's initialize
+    def initialize(klass, options = {})
+      opts = {
+        :initial_size => 1,
+        :max_size     => nil,
+        :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

data/lib/celluloid/receivers.rb

@@ -10,17 +10,21 @@ module Celluloid
 
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
-      receiver = Receiver.new block
+      if Celluloid.exclusive?
+        Thread.mailbox.receive(timeout, &block)
+      else
+        receiver = Receiver.new block
 
-      if timeout
-        receiver.timer = @timers.add(timeout) do
-          @receivers.delete receiver
-          receiver.resume
+        if timeout
+          receiver.timer = @timers.add(timeout) do
+            @receivers.delete receiver
+            receiver.resume
+          end
         end
-      end
 
-      @receivers << receiver
-      Task.suspend :receiving
+        @receivers << receiver
+        Task.suspend :receiving
+      end
     end
 
     # How long to wait until the next timer fires

data/lib/celluloid/signals.rb

@@ -9,8 +9,9 @@ module Celluloid
 
     # Wait for the given signal and return the associated value
     def wait(signal)
-      tasks = @waiting[signal]
+      raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
+      tasks = @waiting[signal]
       case tasks
       when Array
         tasks << Task.current

data/lib/celluloid/supervisor.rb

@@ -28,7 +28,7 @@ module Celluloid
 
       begin
         @actor = @klass.new_link(*@args, &@block)
-      rescue => ex
+      rescue
         failures += 1
         if failures >= start_attempts
           failures = 0
@@ -45,6 +45,9 @@ module Celluloid
 
     # When actors die, regardless of the reason, restart them
     def restart_actor(actor, reason)
+      # If the actor we're supervising exited cleanly, exit the supervisor cleanly too
+      terminate unless reason
+
       start_actor if @started
     end
 

data/lib/celluloid/thread_pool.rb

@@ -4,7 +4,7 @@ module Celluloid
   # Maintain a thread pool FOR SPEED!!
   module ThreadPool
     @pool = []
-    @lock = Mutex.new
+    @mutex = Mutex.new
 
     # TODO: should really adjust this based on usage
     @max_idle = 16
@@ -14,7 +14,7 @@ module Celluloid
 
       # Get a thread from the pool, running the given block
       def get(&block)
-        @lock.synchronize do
+        @mutex.synchronize do
           if @pool.empty?
             thread = create
           else
@@ -28,7 +28,7 @@ module Celluloid
 
       # Return a thread to the pool
       def put(thread)
-        @lock.synchronize do
+        @mutex.synchronize do
           if @pool.size >= @max_idle
             thread[:queue] << nil
           else
@@ -41,14 +41,17 @@ module Celluloid
       def create
         queue = Queue.new
         thread = Thread.new do
-          begin
-            while func = queue.pop
-              func.call
+          while proc = queue.pop
+            begin
+              proc.call
+            rescue => ex
+              Logger.crash("thread crashed", ex)
             end
-          rescue Exception => ex
-            Logger.crash("#{self} internal failure", ex)
+
+            put thread
           end
         end
+
         thread[:queue] = queue
         thread
       end

data/lib/celluloid/version.rb

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

data/spec/support/actor_examples.rb

@@ -49,6 +49,15 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.class.should == actor_class
   end
 
+  it "compares with the actor's class in a case statement" do
+    case actor_class.new("Troy McClure")
+    when actor_class
+      true
+    else
+      false
+    end.should be_true
+  end
+
   it "handles synchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.greet.should == "Hi, I'm Troy McClure"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-24 00:00:00.000000000 Z
+date: 2012-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70145052114120 !ruby/object:Gem::Requirement
+  requirement: &70248586219120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,21 +21,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145052114120
+  version_requirements: *70248586219120
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70145052113520 !ruby/object:Gem::Requirement
+  requirement: &70248586218540 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.7.0
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145052113520
+  version_requirements: *70248586218540
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
-  requirement: &70145052113020 !ruby/object:Gem::Requirement
+  requirement: &70248586217360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145052113020
+  version_requirements: *70248586217360
 description: Celluloid is a concurrent object framework inspired by the Actor Model
 email:
 - tony.arcieri@gmail.com
@@ -64,6 +64,7 @@ files:
 - lib/celluloid/links.rb
 - lib/celluloid/logger.rb
 - lib/celluloid/mailbox.rb
+- lib/celluloid/pool.rb
 - lib/celluloid/receivers.rb
 - lib/celluloid/registry.rb
 - lib/celluloid/responses.rb