celluloid 0.5.0 → 0.6.0

data/README.md

@@ -357,13 +357,43 @@ send them a value in the process:
 	  end
 	end
 
-The wait_for_signal method in turn calls a method called "wait". Wait suspends
+The #wait_for_signal method in turn calls a method called "wait". Wait suspends
 the running method until another method of the same object calls the "signal"
 method with the same label.
 
-The send_signal method of this class does just that, signaling "ponycopter"
+The #send_signal method of this class does just that, signaling "ponycopter"
 with the given value. This value is returned from the original wait call.
 
+Protocol Interaction
+--------------------
+
+The asynchronous message protocol Celluloid uses can be used directly to add
+new behavior to actors.
+
+To send a raw asynchronous message to an actor, use:
+
+    actor.mailbox << MyMessage.new
+
+Methods can wait on incoming MyMessage objects using the #receive method:
+
+    class MyActor
+      def initialize
+        wait_for_my_messages!
+      end
+
+      def wait_for_my_messages
+        loop do
+          message = receive { |msg| msg.is_a? MyMessage }
+		  puts "Got a MyMessage: #{message.inspect}"
+        end
+      end
+    end
+
+The #receive method takes a block, and yields any incoming messages which are
+received by the current actor to the block, waiting for the block to return
+true. Calls to #receive sleep until a message is received which makes the
+block return true, at which point the matching message is returned.
+
 Handling I/O with Celluloid::IO
 -------------------------------
 
@@ -456,6 +486,10 @@ Here are a few rules you can follow to keep this from happening:
    using Fibers, and why can't it be solved by a block? If you've got a really
    good reason and you're feeling lucky, knock yourself out.
 
+5. If you need to mock the behaviour of an Actor, you should mock its subject
+   rather than the proxy itself (#actor_subject). This ensures that any time
+   the subject calls methods on self, they will also be appropriately mocked.
+
 On Thread Safety in Ruby
 ------------------------
 

data/lib/celluloid.rb

@@ -1,4 +1,6 @@
 require 'logger'
+require 'thread'
+require 'celluloid/fibers_are_hard'
 
 module Celluloid
   @logger = Logger.new STDERR
@@ -23,6 +25,41 @@ module Celluloid
 
       actor
     end
+
+    # Receive an asynchronous message
+    def receive(&block)
+      actor = Thread.current[:actor]
+      if actor
+        actor.receive(&block)
+      else
+        Thread.current.mailbox.receive(&block)
+      end
+    end
+
+    # Create a fiber that participates in the Celluloid protocol
+    def fiber(*args)
+      actor   = Thread.current[:actor]
+      proxy   = Thread.current[:actor_proxy]
+      mailbox = Thread.current[:mailbox]
+
+      Fiber.new do
+        Thread.current[:actor]       = actor
+        Thread.current[:actor_proxy] = proxy
+        Thread.current[:mailbox]     = mailbox
+
+        yield(*args)
+      end
+    end
+
+    # Resume a fiber that participates in the Celluloid protocol
+    def resume_fiber(fiber, value = nil)
+      actor = Thread.current[:actor]
+      if actor
+        actor.run_fiber fiber, value
+      else
+        fiber.resume value
+      end
+    end
   end
 
   # Class methods added to classes which include Celluloid
@@ -64,8 +101,17 @@ module Celluloid
       @exit_handler = callback.to_sym
     end
 
-    # Obtain the exit handler method for this class
-    def exit_handler; @exit_handler; end
+    # Obtain the exit handler for this actor
+    attr_reader :exit_handler
+
+    # Configure a custom mailbox factory
+    def use_mailbox(klass = nil, &block)
+      if block
+        define_method(:mailbox_factory, &block)
+      else
+        define_method(:mailbox_factory) { klass.new }
+      end
+    end
   end
 
   #
@@ -112,6 +158,18 @@ module Celluloid
     Celluloid.current_actor
   end
 
+  # Obtain the Ruby object the actor is wrapping. This should ONLY be used
+  # for a limited set of use cases like runtime metaprogramming. Interacting
+  # directly with the wrapped object foregoes any kind of thread safety that
+  # Celluloid would ordinarily provide you, and the object is guaranteed to
+  # be shared with at least the actor thread. Tread carefully.
+  def wrapped_object; self; end
+
+  # Receive an asynchronous message via the actor protocol
+  def receive(&block)
+    Celluloid.receive(&block)
+  end
+
   # Perform a blocking or computationally intensive action inside an
   # asynchronous thread pool, allowing the caller to continue processing other
   # messages in its mailbox in the meantime
@@ -151,6 +209,7 @@ require 'celluloid/core_ext'
 require 'celluloid/events'
 require 'celluloid/linking'
 require 'celluloid/mailbox'
+require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
 require 'celluloid/signals'
@@ -159,6 +218,7 @@ require 'celluloid/actor'
 require 'celluloid/actor_pool'
 require 'celluloid/supervisor'
 require 'celluloid/future'
+require 'celluloid/application'
 
 require 'celluloid/io'
 require 'celluloid/tcp_server'

data/lib/celluloid/actor.rb

@@ -1,18 +1,3 @@
-require 'thread'
-
-begin
-  require 'fiber'
-rescue LoadError => ex
-  if defined? JRUBY_VERSION
-    raise LoadError, "Celluloid requires JRuby 1.9 mode. Please pass the --1.9 flag or set JRUBY_OPTS=--1.9"
-  elsif defined? Rubinius
-    # If we're on Rubinius, we can still work in 1.8 mode
-    Fiber = Rubinius::Fiber
-  else
-    raise ex
-  end
-end
-
 module Celluloid
   # Don't do Actor-like things outside Actor scope
   class NotActorError < StandardError; end
@@ -41,47 +26,67 @@ module Celluloid
     attr_reader :links
     attr_reader :mailbox
 
+    # Invoke a method on the given actor via its mailbox
+    def self.call(mailbox, meth, *args, &block)
+      our_mailbox = Thread.current.mailbox
+      call = SyncCall.new(our_mailbox, meth, args, block)
 
-    # Wrap the given subject object with an Actor
-    def initialize(subject)
-      @subject  = subject
-      @mailbox = initialize_mailbox
-      @links   = Links.new
-      @signals = Signals.new
-      @proxy   = ActorProxy.new(self, @mailbox)
-      @running = true
-
-      @thread = Pool.get
-      @thread[:queue] << proc do
-        initialize_thread_locals
-        run
+      begin
+        mailbox << call
+      rescue MailboxError
+        raise DeadActorError, "attempted to call a dead actor"
       end
-    end
 
-    # Create the mailbox for this actor
-    #
-    # This implemententation is intended to be overridden in special-case
-    # subclasses of Celluloid::Actor which use a custom mailbox
-    def initialize_mailbox
-      Mailbox.new
+      if Celluloid.actor?
+        # Yield to the actor scheduler, which resumes us when we get a response
+        response = Fiber.yield(call)
+      else
+        # Otherwise we're inside a normal thread, so block
+        response = our_mailbox.receive do |msg|
+          msg.is_a? Response and msg.call_id == call.id
+        end
+      end
+
+      response.value
     end
 
-    # Configure thread locals for the running thread
-    def initialize_thread_locals
-      Thread.current[:actor]       = self
-      Thread.current[:actor_proxy] = @proxy
-      Thread.current[:mailbox]     = @mailbox
+    # Invoke a method asynchronously on an actor via its mailbox
+    def self.async(mailbox, meth, *args, &block)
+      our_mailbox = Thread.current.mailbox
+      begin
+        mailbox << AsyncCall.new(our_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
 
-    # Run the actor loop
-    def run
-      process_messages
-      cleanup ExitEvent.new(@proxy)
-    rescue Exception => ex
-      @running = false
-      handle_crash(ex)
-    ensure
-      Pool.put @thread
+    # Wrap the given subject with an Actor
+    def initialize(subject)
+      @subject = subject
+
+      if subject.respond_to? :mailbox_factory
+        @mailbox = subject.mailbox_factory
+      else
+        @mailbox = Celluloid::Mailbox.new
+      end
+
+      @links     = Links.new
+      @signals   = Signals.new
+      @receivers = Receivers.new
+      @proxy     = ActorProxy.new(@mailbox)
+      @running   = true
+      @pending_calls = {}
+
+      @thread = Pool.get do
+        Thread.current[:actor]       = self
+        Thread.current[:actor_proxy] = @proxy
+        Thread.current[:mailbox]     = @mailbox
+
+        run
+      end
     end
 
     # Is this actor alive?
@@ -105,56 +110,72 @@ module Celluloid
       @signals.wait name
     end
 
-    #######
-    private
-    #######
-
-    # Process incoming messages
-    def process_messages
-      pending_calls = {}
+    # Receive an asynchronous message
+    def receive(&block)
+      @receivers.receive(&block)
+    end
 
+    # Run the actor loop
+    def run
       while @running
         begin
           message = @mailbox.receive
-        rescue MailboxShutdown
-          # If the mailbox detects shutdown, exit the actor
-          @running = false
         rescue ExitEvent => exit_event
-          fiber = Fiber.new do
-            initialize_thread_locals
-            handle_exit_event exit_event
-          end
-
-          call = fiber.resume
-          pending_calls[call] = fiber if fiber.alive?
-
+          fiber = Celluloid.fiber { handle_exit_event exit_event; nil }
+          run_fiber fiber
           retry
         end
 
-        case message
-        when Call
-          fiber = Fiber.new do
-            initialize_thread_locals
-            message.dispatch(@subject)
-          end
-
-          call = fiber.resume
-          pending_calls[call] = fiber if fiber.alive?
-        when Response
-          fiber = pending_calls.delete(message.call)
-
-          if fiber
-            call = fiber.resume message
-            pending_calls[call] = fiber if fiber.alive?
-          end
-        end # unexpected messages are ignored
+        handle_message message
       end
+
+      cleanup ExitEvent.new(@proxy)
+    rescue MailboxShutdown
+      # If the mailbox detects shutdown, exit the actor
+      @running = false
+    rescue Exception => ex
+      @running = false
+      handle_crash(ex)
+    ensure
+      Pool.put @thread
+    end
+
+    # Run a method, handling when its Fiber is suspended
+    def run_fiber(fiber, value = nil)
+      result = fiber.resume value
+      if result.is_a? Celluloid::Call
+        @pending_calls[result.id] = fiber if fiber.alive?
+      elsif result
+        warning = "non-call returned from fiber: #{result.class}"
+        Celluloid.logger.debug warning if Celluloid.logger
+      end
+      nil
+    end
+
+    # Handle an incoming message
+    def handle_message(message)
+      case message
+      when Call
+        fiber = Celluloid.fiber { message.dispatch(@subject); nil }
+        run_fiber fiber
+      when Response
+        fiber = @pending_calls.delete(message.call_id)
+
+        if fiber
+          run_fiber fiber, message
+        else
+          warning = "spurious response to call #{message.call_id}"
+          Celluloid.logger.debug if Celluloid.logger
+        end
+      else
+        @receivers.handle_message(message)
+      end
+      message
     end
 
     # Handle exit events received by this actor
     def handle_exit_event(exit_event)
-      klass = @subject.class
-      exit_handler = klass.exit_handler if klass.respond_to? :exit_handler
+      exit_handler = @subject.class.exit_handler
       if exit_handler
         return @subject.send(exit_handler, exit_event.actor, exit_event.reason)
       end
@@ -176,6 +197,12 @@ module Celluloid
     def cleanup(exit_event)
       @mailbox.shutdown
       @links.send_event exit_event
+
+      begin
+        @subject.finalize if @subject.respond_to? :finalize
+      rescue Exception => finalizer_exception
+        log_error(finalizer_exception, "#{@subject.class}#finalize crashed!")
+      end
     end
 
     # Log errors when an actor crashes

data/lib/celluloid/actor_pool.rb

@@ -11,20 +11,23 @@ module Celluloid
       class << self
         attr_accessor :max_idle
 
-        def get
+        def get(&block)
           @lock.synchronize do
             if @pool.empty?
-              create
+              thread = create
             else
-              @pool.shift
+              thread = @pool.shift
             end
+
+            thread[:queue] << block
+            thread
           end
         end
 
         def put(thread)
           @lock.synchronize do
             if @pool.size >= @max_idle
-              thread.kill
+              thread[:queue] << nil
             else
               @pool << thread
             end
@@ -35,13 +38,10 @@ module Celluloid
           queue = Queue.new
           thread = Thread.new do
             begin
-              while true
-                queue.pop.call
+              while func = queue.pop
+                func.call
               end
             rescue Exception => ex
-              # Rubinius hax
-              raise if defined?(Thread::Die) and ex.is_a? Thread::Die
-
               message = "Celluloid::Actor::Pool internal failure:\n"
               message << "#{ex.class}: #{ex.to_s}\n"
               message << ex.backtrace.join("\n")

data/lib/celluloid/actor_proxy.rb

@@ -3,41 +3,40 @@ module Celluloid
   # dispatches calls and casts to normal Ruby objects which are running inside
   # of their own threads.
   class ActorProxy
-    # FIXME: not nearly enough methods are delegated here
     attr_reader :mailbox
 
-    def initialize(actor, mailbox)
-      @actor, @mailbox = actor, mailbox
+    def initialize(mailbox, klass = "Object")
+      @mailbox, @klass = mailbox, klass
     end
 
     def send(meth, *args, &block)
-      __call :send, meth, *args, &block
+      Actor.call @mailbox, :send, meth, *args, &block
     end
 
     def respond_to?(meth)
-      __call :respond_to?, meth
+      Actor.call @mailbox, :respond_to?, meth
     end
 
     def methods(include_ancestors = true)
-      __call :methods, include_ancestors
+      Actor.call @mailbox, :methods, include_ancestors
     end
 
     def alive?
-      @actor.alive?
+      @mailbox.alive?
     end
 
     def to_s
-      __call :to_s
+      Actor.call @mailbox, :to_s
     end
 
     def inspect
-      return __call :inspect if alive?
-      "#<Celluloid::Actor(#{@actor.class}:0x#{@actor.object_id.to_s(16)}) dead>"
+      "#<Celluloid::Actor(#{@klass}) dead>" unless alive?
+      Actor.call @mailbox, :inspect
     end
 
     # Create a Celluloid::Future which calls a given method
     def future(method_name, *args, &block)
-      Celluloid::Future.new { __call method_name, *args, &block }
+      Celluloid::Future.new { Actor.call @mailbox, method_name, *args, &block }
     end
 
     # Terminate the associated actor
@@ -61,64 +60,11 @@ module Celluloid
       # bang methods are async calls
       if meth.to_s.match(/!$/)
         unbanged_meth = meth.to_s.sub(/!$/, '')
-        our_mailbox = Thread.current.mailbox
-
-        begin
-          @mailbox << AsyncCall.new(our_mailbox, unbanged_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
-
-        return # casts are async and return immediately
+        Actor.async @mailbox, unbanged_meth, *args, &block
+        return
       end
 
-      __call(meth, *args, &block)
-    end
-
-    #######
-    private
-    #######
-
-    # Make a synchronous call to the actor we're proxying to
-    def __call(meth, *args, &block)
-      our_mailbox = Thread.current.mailbox
-      call = SyncCall.new(our_mailbox, meth, args, block)
-
-      begin
-        @mailbox << call
-      rescue MailboxError
-        raise DeadActorError, "attempted to call a dead actor"
-      end
-
-      if Celluloid.actor?
-        # Yield to the actor scheduler, which resumes us when we get a response
-        response = Fiber.yield(call)
-      else
-        # Otherwise we're inside a normal thread, so block
-        response = our_mailbox.receive do |msg|
-          msg.is_a? Response and msg.call == call
-        end
-      end
-
-      case response
-      when SuccessResponse
-        response.value
-      when ErrorResponse
-        ex = response.value
-
-        if ex.is_a? AbortError
-          # Aborts are caused by caller error, so ensure they capture the
-          # caller's backtrace instead of the receiver's
-          raise ex.cause.class.new(ex.cause.message)
-        else
-          raise ex
-        end
-      else
-        raise "don't know how to handle #{response.class} messages!"
-      end
+      Actor.call @mailbox, meth, *args, &block
     end
   end
 end

data/lib/celluloid/application.rb

@@ -0,0 +1,78 @@
+module Celluloid
+  # Applications describe and manage networks of Celluloid actors
+  class Application
+    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?
+
+          Celluloid.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
+
+      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'] || []
+      end
+
+      def supervise
+        Supervisor.new_link(@as, @klass, *@args)
+      end
+    end
+  end
+end

data/lib/celluloid/calls.rb

@@ -1,17 +1,18 @@
 module Celluloid
   # Calls represent requests to an actor
   class Call
-    attr_reader :caller, :method, :arguments, :block
-    
+    attr_reader :id, :caller, :method, :arguments, :block
+
     def initialize(caller, method, arguments, block)
+      @id = object_id # memoize object ID for serialization
       @caller, @method, @arguments, @block = caller, method, arguments, block
     end
-    
+
     def check_signature(obj)
       unless obj.respond_to? @method
         raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}"
       end
-      
+
       arity = obj.method(@method).arity
       if arity >= 0
         if arguments.size != arity
@@ -25,24 +26,24 @@ module Celluloid
       end
     end
   end
-  
+
   # Synchronous calls wait for a response
   class SyncCall < Call
     def dispatch(obj)
       begin
         check_signature(obj)
       rescue Exception => ex
-        respond ErrorResponse.new(self, AbortError.new(ex))
+        respond ErrorResponse.new(@id, AbortError.new(ex))
         return
       end
-      
+
       begin
         result = obj.send @method, *@arguments, &@block
       rescue Exception => exception
         # Exceptions that occur during synchronous calls are reraised in the
         # context of the caller
-        respond ErrorResponse.new(self, exception)
-        
+        respond ErrorResponse.new(@id, exception)
+
         if exception.is_a? AbortError
           # Aborting indicates a protocol error on the part of the caller
           # It should crash the caller, but the exception isn't reraised
@@ -52,43 +53,48 @@ module Celluloid
           raise exception
         end
       end
-      
-      respond SuccessResponse.new(self, result)      
-      true
+
+      respond SuccessResponse.new(@id, result)
     end
-    
+
     def cleanup
       exception = DeadActorError.new("attempted to call a dead actor")
-      respond ErrorResponse.new(self, exception)
+      respond ErrorResponse.new(@id, exception)
     end
-    
+
     #######
     private
     #######
-    
+
     def respond(message)
       @caller << message
     rescue MailboxError
       # It's possible the caller exited or crashed before we could send a
       # response to them.
-    end  
+    end
   end
-  
+
   # Asynchronous calls don't wait for a response
   class AsyncCall < Call
     def dispatch(obj)
       begin
         check_signature(obj)
       rescue Exception => ex
-        obj.__log_error ex, "#{obj.class}: async call failed!"
+        log_error ex, "#{obj.class}: async call failed!"
         return
       end
-      
+
       obj.send(@method, *@arguments, &@block)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
-      obj.__log_error ex, "#{obj.class}: async call aborted!"
+      obj.log_error ex, "#{obj.class}: async call aborted!"
+    end
+    
+    def log_error(ex, message)
+      message << "\n#{ex.class}: #{ex.to_s}\n"
+      message << ex.backtrace.join("\n")
+      Celluloid.logger.error message if Celluloid.logger
     end
   end
 end
-    
+

data/lib/celluloid/fibers_are_hard.rb

@@ -0,0 +1,33 @@
+# Let's go shopping!
+begin
+  require 'fiber'
+rescue LoadError => ex
+  if defined? JRUBY_VERSION
+    if RUBY_VERSION < "1.9.2"
+      raise LoadError, "Celluloid requires JRuby 1.9 mode. Please pass the --1.9 flag or set JRUBY_OPTS=--1.9"
+    end
+
+    # Fibers are broken on JRuby 1.6.5. This works around the issue
+    if JRUBY_VERSION == "1.6.5"
+      require 'jruby'
+      org.jruby.ext.fiber.FiberExtLibrary.new.load(JRuby.runtime, false)
+      class org::jruby::ext::fiber::ThreadFiber
+        field_accessor :state
+      end
+
+      class Fiber
+        def alive?
+          JRuby.reference(self).state != org.jruby.ext.fiber.ThreadFiberState::FINISHED
+        end
+      end
+    else
+      # 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
+  else
+    raise ex
+  end
+end

data/lib/celluloid/io.rb

@@ -1,41 +1,15 @@
 require 'celluloid/io/waker'
 require 'celluloid/io/reactor'
 require 'celluloid/io/mailbox'
-require 'celluloid/io/actor'
 
 module Celluloid
   # Actors which can run alongside other I/O operations
   module IO
     def self.included(klass)
       klass.send :include, ::Celluloid
-      klass.send :extend,  IO::ClassMethods
+      klass.use_mailbox Celluloid::IO::Mailbox
     end
 
-    # Class methods added to classes which include Celluloid::IO
-    module ClassMethods
-      # Create a new actor
-      def new(*args, &block)
-        proxy = IO::Actor.new(allocate).proxy
-        proxy.send(:initialize, *args, &block)
-        proxy
-      end
-
-      # Create a new actor and link to the current one
-      def new_link(*args, &block)
-        current_actor = Thread.current[:actor]
-        raise NotActorError, "can't link outside actor context" unless current_actor
-
-        proxy = IO::Actor.new(allocate).proxy
-        current_actor.link proxy
-        proxy.send(:initialize, *args, &block)
-        proxy
-      end
-    end
-
-    #
-    # Instance methods
-    #
-
     # Wait for the given IO object to become readable
     def wait_readable(io, &block)
       # Law of demeter be damned!

data/lib/celluloid/io/mailbox.rb

@@ -4,7 +4,7 @@ module Celluloid
   module IO
     # An alternative implementation of Celluloid::Mailbox using Wakers
     class Mailbox < Celluloid::Mailbox
-      attr_reader :reactor
+      attr_reader :reactor, :waker
 
       def initialize
         @messages = []
@@ -50,7 +50,7 @@ module Celluloid
         end until message
 
         message
-      rescue DeadWakerError
+      rescue IOError, DeadWakerError
         shutdown # force shutdown of the mailbox
         raise MailboxShutdown, "mailbox shutdown called during receive"
       end

data/lib/celluloid/io/reactor.rb

@@ -32,7 +32,7 @@ module Celluloid
         [[readers, @readers], [writers, @writers]].each do |ios, registered|
           ios.each do |io|
             fiber = registered.delete io
-            fiber.resume if fiber
+            Celluloid.resume_fiber(fiber) if fiber
           end
         end
       end

data/lib/celluloid/linking.rb

@@ -50,7 +50,7 @@ module Celluloid
     def inspect
       @lock.synchronize do
         links = @links.to_a.map { |l| "#{l.class}:#{l.object_id}" }.join(',')
-        "#<Celluloid::Links[#{links}]>"
+        "#<#{self.class}[#{links}]>"
       end
     end
   end

data/lib/celluloid/mailbox.rb

@@ -86,6 +86,11 @@ module Celluloid
       true
     end
 
+    # Is the mailbox alive?
+    def alive?
+      !@dead
+    end
+
     # Cast to an array
     def to_a
       @lock.synchronize { @messages.dup }
@@ -98,7 +103,7 @@ module Celluloid
 
     # Inspect the contents of the Mailbox
     def inspect
-      "#<Celluloid::Mailbox:#{object_id} [#{map { |m| m.inspect }.join(', ')}]>"
+      "#<#{self.class}:#{object_id.to_s(16)} @messages=[#{map { |m| m.inspect }.join(', ')}]>"
     end
   end
 end

data/lib/celluloid/receivers.rb

@@ -0,0 +1,36 @@
+module Celluloid
+  # Allow methods to directly interact with the actor protocol
+  class Receivers
+    def initialize
+      @handlers = []
+    end
+
+    # Receive an asynchronous message
+    def receive(&block)
+      raise ArgumentError, "receive must be given a block" unless block
+
+      @handlers << [Fiber.current, block]
+      Fiber.yield
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      handler = nil
+
+      @handlers.each_with_index do |(fiber, block), index|
+        if block.call(message)
+          handler = index
+          break
+        end
+      end
+
+      if handler
+        fiber, _ = @handlers.delete_at handler
+        Celluloid.resume_fiber fiber, message
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/celluloid/responses.rb

@@ -1,10 +1,10 @@
 module Celluloid
   # Responses to calls
   class Response
-    attr_reader :call, :value
+    attr_reader :call_id, :value
     
-    def initialize(call, value)
-      @call, @value = call, value
+    def initialize(call_id, value)
+      @call_id, @value = call_id, value
     end
   end
   
@@ -12,5 +12,15 @@ module Celluloid
   class SuccessResponse < Response; end
   
   # Call was aborted due to caller error
-  class ErrorResponse < Response; end
+  class ErrorResponse < Response
+    def value
+      if super.is_a? AbortError
+        # Aborts are caused by caller error, so ensure they capture the
+        # caller's backtrace instead of the receiver's
+        raise super.cause.class.new(super.cause.message)
+      else
+        raise super
+      end
+    end
+  end
 end

data/lib/celluloid/signals.rb

@@ -18,7 +18,9 @@ module Celluloid
       fibers = @waiting.delete name
       return unless fibers
       
-      fibers.each { |fiber| fiber.resume value }
+      fibers.each do |fiber|
+        Celluloid.resume_fiber fiber, value
+      end
       true
     end
   end

data/lib/celluloid/supervisor.rb

@@ -4,37 +4,50 @@ module Celluloid
   class Supervisor
     include Celluloid
     trap_exit :restart_actor
-    
+
     # Retrieve the actor this supervisor is supervising
     attr_reader :actor
-    
+
     def self.supervise(klass, *args, &block)
       new(nil, klass, *args, &block)
     end
-    
+
     def self.supervise_as(name, klass, *args, &block)
       new(name, klass, *args, &block)
     end
-    
+
     def initialize(name, klass, *args, &block)
       @name, @klass, @args, @block = name, klass, args, block
       start_actor
     end
-    
-    def start_actor
-      @actor = @klass.new_link(*@args, &@block)
+
+    def start_actor(start_attempts = 2, sleep_interval = 30)
+      failures = 0
+
+      begin
+        @actor = @klass.new_link(*@args, &@block)
+      rescue
+        failures += 1
+        if failures >= start_attempts
+          failures = 0
+          Celluloid.logger.warn "#{@klass} is crashing on initialize repeatedly, sleeping for #{sleep_interval} seconds"
+          sleep sleep_interval
+        end
+        retry
+      end
+
       Celluloid::Actor[@name] = @actor if @name
     end
-    
+
     # When actors die, regardless of the reason, restart them
     def restart_actor(actor, reason)
       start_actor
     end
-    
+
     def inspect
-      str = "#<Celluloid::Supervisor(#{@klass})"
+      str = "#<#{self.class}(#{@klass}):0x#{object_id.to_s(16)}"
       str << " " << @args.map { |arg| arg.inspect }.join(' ') unless @args.empty?
       str << ">"
     end
   end
-end
+end

data/lib/celluloid/version.rb

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

metadata

@@ -1,38 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.5.0
-  prerelease: 
+  prerelease:
+  version: 0.6.0
 platform: ruby
 authors:
 - Tony Arcieri
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000Z
+date: 2011-11-19 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70182211411320 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2056 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+    none: false
+  requirement: *2056
   prerelease: false
-  version_requirements: *70182211411320
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70182211410760 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2074 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.7.0
-  type: :development
+    none: false
+  requirement: *2074
   prerelease: false
-  version_requirements: *70182211410760
+  type: :development
 description: Celluloid is a concurrent object framework inspired by the Actor Model
 email:
 - tony@medioh.com
@@ -41,20 +41,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/celluloid.rb
 - lib/celluloid/actor.rb
 - lib/celluloid/actor_pool.rb
 - lib/celluloid/actor_proxy.rb
+- lib/celluloid/application.rb
 - lib/celluloid/calls.rb
 - lib/celluloid/core_ext.rb
 - lib/celluloid/events.rb
+- lib/celluloid/fibers_are_hard.rb
 - lib/celluloid/future.rb
-- lib/celluloid/io/actor.rb
-- lib/celluloid/io/mailbox.rb
-- lib/celluloid/io/reactor.rb
-- lib/celluloid/io/waker.rb
 - lib/celluloid/io.rb
 - lib/celluloid/linking.rb
 - lib/celluloid/mailbox.rb
+- lib/celluloid/receivers.rb
 - lib/celluloid/registry.rb
 - lib/celluloid/responses.rb
 - lib/celluloid/rspec.rb
@@ -62,31 +62,34 @@ files:
 - lib/celluloid/supervisor.rb
 - lib/celluloid/tcp_server.rb
 - lib/celluloid/version.rb
-- lib/celluloid.rb
+- lib/celluloid/io/mailbox.rb
+- lib/celluloid/io/reactor.rb
+- lib/celluloid/io/waker.rb
 homepage: https://github.com/tarcieri/celluloid
 licenses:
 - MIT
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
+  none: false
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.10
-signing_key: 
+rubyforge_project:
+rubygems_version: 1.8.9
+signing_key:
 specification_version: 3
 summary: Celluloid is a concurrent object framework inspired by the Actor Model
 test_files: []
-has_rdoc: 
+has_rdoc:
+...

data/lib/celluloid/io/actor.rb

@@ -1,10 +0,0 @@
-module Celluloid
-  module IO
-    class Actor < Celluloid::Actor
-      # Use the special Celluloid::IO::Mailbox to handle incoming requests
-      def initialize_mailbox
-        Celluloid::IO::Mailbox.new
-      end
-    end
-  end
-end