celluloid 0.2.1 → 0.2.2

data/README.md

@@ -6,13 +6,16 @@ Celluloid
 > computers on a network, only able to communicate with messages"  
 > _--Alan Kay, creator of Smalltalk, on the meaning of "object oriented programming"_
 
-Celluloid is a concurrent object framework for Ruby inspired by Erlang and the
-Actor model. Celluloid gives you thread-backed objects that run concurrently,
-providing the simplicity of Ruby objects for the most common use cases, but
-also the ability to call methods _asynchronously_, allowing the receiver to do
-things in the background while the caller carries on with its business.
-These concurrent objects are called "actors". Actors are somewhere in between
-the kind of object you're typically used to working with and a network service.
+Celluloid is a concurrent object framework for Ruby inspired by Erlang and
+the Actor model. Celluloid gives you thread-backed objects that run
+concurrently, providing the simplicity of Ruby objects for the most common
+use cases, but also the ability to call methods _asynchronously_, allowing 
+the receiver to do things in the background while the caller carries on 
+with its business. These concurrent objects are called "actors". Actors are
+somewhere in between the kind of object you're typically used to working
+with and a network service.
+
+Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
 
 Supported Platforms
 -------------------
@@ -87,7 +90,8 @@ exceptions will crash the receiver, and making an asynchronous call to a
 crashed object will not raise an error.
 
 However, you can still handle errors created by asynchronous calls using
-two features of Celluloid called _supervisors_ and _linking_.
+two features of Celluloid called _supervisors_ and _linking_. See the
+corresponding sections below for more information.
 
 Futures
 -------
@@ -107,7 +111,10 @@ report method from the charlie object used in the above example using a future:
 The call to charlie.future immediately returns a Celluloid::Future object,
 regardless of how long it takes to execute the "report" method. To obtain
 the result of the call to "report", we call the _value_ method of the
-future object. This call will block until the method call is available.
+future object. This call will block until the value returned from the method 
+call is available (i.e. the method has finished executing). If an exception
+occured during the method call, the call to future.value will reraise the
+same exception.
 
 Futures also allow you to background the computation of any block:
 
@@ -367,4 +374,4 @@ Contributing to Celluloid
 Copyright
 ---------
 
-Copyright (c) 2011 Tony Arcieri. See LICENSE.txt for further details.
+Copyright (c) 2011 Tony Arcieri. See LICENSE.txt for further details.

data/lib/celluloid/actor.rb

@@ -60,8 +60,7 @@ module Celluloid
       def spawn_link(*args, &block)
         current_actor = Thread.current[:actor]
         raise NotActorError, "can't link outside actor context" unless current_actor
-        
-        # FIXME: this is a bit repetitive with the code above
+
         actor = allocate
         proxy = actor.__start_actor        
         current_actor.link actor
@@ -139,6 +138,30 @@ module Celluloid
       def wait(name)
         @_signals.wait name
       end
+      
+      #
+      # Async calls
+      #
+      
+      def method_missing(meth, *args, &block)
+        # bang methods are async calls
+        if meth.to_s.match(/!$/) 
+          unbanged_meth = meth.to_s.sub(/!$/, '')
+
+          begin
+            @_mailbox << AsyncCall.new(@_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
+        end
+        
+        super
+      end
     end
     
     # Internal methods not intended as part of the public API
@@ -242,7 +265,6 @@ module Celluloid
       end
       
       # Log errors when an actor crashes
-      # FIXME: This should probably thunk to a real logger
       def __log_error(ex, message = "#{self.class} crashed!")
         message << "\n#{ex.class}: #{ex.to_s}\n"
         message << ex.backtrace.join("\n")

data/lib/celluloid/actor_proxy.rb

@@ -92,12 +92,20 @@ module Celluloid
           msg.is_a? Response and msg.call == call
         end
       end
-      
+
       case response
       when SuccessResponse
         response.value
       when ErrorResponse
-        raise response.value
+        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

data/lib/celluloid/calls.rb

@@ -6,50 +6,88 @@ module Celluloid
     def initialize(caller, method, arguments, block)
       @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
+          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{arity})"
+        end
+      elsif arity < -1
+        mandatory_args = -arity - 1
+        if arguments.size < mandatory_args
+          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{mandatory_args})"
+        end
+      end
+    end
   end
   
   # Synchronous calls wait for a response
   class SyncCall < Call
     def dispatch(obj)
-      unless obj.respond_to? @method
-        exception = NoMethodError.new("undefined method `#{@method}' for #{obj.inspect}")
-        @caller << ErrorResponse.new(self, exception)
+      begin
+        check_signature(obj)
+      rescue Exception => ex
+        respond ErrorResponse.new(self, AbortError.new(ex))
         return
       end
       
       begin
         result = obj.send @method, *@arguments, &@block
-      rescue AbortError => exception
-        # Aborting indicates a protocol error on the part of the caller
-        # It should crash the caller, but the exception isn't reraised
-        @caller << ErrorResponse.new(self, exception.cause)
-        return
       rescue Exception => exception
         # Exceptions that occur during synchronous calls are reraised in the
         # context of the caller
-        @caller << ErrorResponse.new(self, exception)
+        respond ErrorResponse.new(self, exception)
         
-        # They should also crash the actor where they occurred
-        raise 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
+          return
+        else
+          # Otherwise, it's a bug in this actor and should be reraised
+          raise exception
+        end
       end
-          
-      @caller << SuccessResponse.new(self, result)
+      
+      respond SuccessResponse.new(self, result)      
       true
     end
     
     def cleanup
       exception = DeadActorError.new("attempted to call a dead actor")
-      @caller << ErrorResponse.new(self, exception)
+      respond ErrorResponse.new(self, 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
   
   # Asynchronous calls don't wait for a response
   class AsyncCall < Call
     def dispatch(obj)
-      obj.send(@method, *@arguments, &@block) if obj.respond_to? @method
-    rescue AbortError
+      begin
+        check_signature(obj)
+      rescue Exception => ex
+        obj.__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
-      # FIXME: this should probably get logged
+      obj.__log_error ex, "#{obj.class}: async call aborted!"
     end
   end
 end

data/lib/celluloid/version.rb

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

metadata

@@ -2,7 +2,7 @@
 name: celluloid
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-14 00:00:00 -07:00
+date: 2011-09-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency