celluloid 0.13.0 → 0.14.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e34a9a2d8dc0a227e68e1d8e5a7e4de3a6a99a5a
+  data.tar.gz: 784898577b1163ff5a7756bd8fb4558e105b075c
+SHA512:
+  metadata.gz: e1af2a80fa4944959773aac6b1b3c800d28a64810264e6e08b1d794ec46d40752efd8d144f7c63715acd40e8a5a9576aedc3bad6c8a59a7e4b336c0c37585373
+  data.tar.gz: 0215cc3ab5bb87b222c9483563c4a4c89aac8ec78f6361715cb3dd2088a4908860aafaed8ec4e519f973ba29bbdaede4722973a0c4be3e177b42997aad5401d6

data/README.md

@@ -2,7 +2,6 @@
 =========
 [![Gem Version](https://badge.fury.io/rb/celluloid.png)](http://rubygems.org/gems/celluloid)
 [![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
-[![Dependency Status](https://gemnasium.com/celluloid/celluloid.png)](https://gemnasium.com/celluloid/celluloid)
 [![Code Climate](https://codeclimate.com/github/celluloid/celluloid.png)](https://codeclimate.com/github/celluloid/celluloid)
 [![Coverage Status](https://coveralls.io/repos/celluloid/celluloid/badge.png?branch=master)](https://coveralls.io/r/celluloid/celluloid)
 
@@ -70,7 +69,7 @@ to EventMachine (with a synchronous API instead of callback/deferrable soup)
 is available through the [Celluloid::IO](https://github.com/celluloid/celluloid-io)
 library.
 
-Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
+Like Celluloid? [Join the mailing list/Google Group](http://groups.google.com/group/celluloid-ruby)
 or visit us on IRC at #celluloid on freenode
 
 ### Is it any good?

data/lib/celluloid.rb

@@ -25,6 +25,11 @@ module Celluloid
       !!Thread.current[:celluloid_actor]
     end
 
+    # Retrieve the mailbox for the current thread or lazily initialize it
+    def mailbox
+      Thread.current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
+    end
+
     # Generate a Universally Unique Identifier
     def uuid
       UUID.generate
@@ -61,13 +66,33 @@ module Celluloid
     # Launch default services
     # FIXME: We should set up the supervision hierarchy here
     def boot
+      internal_pool.reset
       Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
       Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
     end
 
+    def register_shutdown
+      return if @shutdown_registered
+      # Terminate all actors at exit
+      at_exit do
+        if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
+          # workaround for MRI bug losing exit status in at_exit block
+          # http://bugs.ruby-lang.org/issues/5218
+          exit_status = $!.status if $!.is_a?(SystemExit)
+          Celluloid.shutdown
+          exit exit_status if exit_status
+        else
+          Celluloid.shutdown
+        end
+      end
+      @shutdown_registered = true
+    end
+
     # Shut down all running actors
     def shutdown
       Timeout.timeout(shutdown_timeout) do
+        internal_pool.shutdown
+
         actors = Actor.all
         Logger.debug "Terminating #{actors.size} actors..." if actors.size > 0
 
@@ -75,14 +100,14 @@ module Celluloid
         Supervisor.root.terminate if Supervisor.root
 
         # Actors cannot self-terminate, you must do it for them
-        Actor.all.each do |actor|
+        actors.each do |actor|
           begin
             actor.terminate!
           rescue DeadActorError, MailboxError
           end
         end
 
-        Actor.all.each do |actor|
+        actors.each do |actor|
           begin
             Actor.join(actor)
           rescue DeadActorError, MailboxError
@@ -91,7 +116,7 @@ module Celluloid
 
         Logger.debug "Shutdown completed cleanly"
       end
-    rescue Timeout::Error => ex
+    rescue Timeout::Error
       Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
     end
   end
@@ -174,13 +199,9 @@ module Celluloid
     # Define the mailbox class for this class
     def mailbox_class(klass = nil)
       if klass
-        @mailbox_class = klass
-      elsif defined?(@mailbox_class)
-        @mailbox_class
-      elsif superclass.respond_to? :mailbox_class
-        superclass.mailbox_class
+        mailbox.class = klass
       else
-        Celluloid::Mailbox
+        mailbox.class
       end
     end
     
@@ -213,7 +234,7 @@ module Celluloid
     def exclusive(*methods)
       if methods.empty?
         @exclusive_methods = :all
-      elsif @exclusive_methods != :all
+      elsif !defined?(@exclusive_methods) || @exclusive_methods != :all
         @exclusive_methods ||= Set.new
         @exclusive_methods.merge methods.map(&:to_sym)
       end
@@ -221,24 +242,53 @@ module Celluloid
 
     # Mark methods as running blocks on the receiver
     def execute_block_on_receiver(*methods)
-      # A noop method in preparation
-      # See https://github.com/celluloid/celluloid/pull/55
+      receiver_block_executions.merge methods.map(&:to_sym)
+    end
+
+    def receiver_block_executions
+      @receiver_block_executions ||= Set.new([:after, :every, :receive])
     end
 
     # Configuration options for Actor#new
     def actor_options
       {
-        :mailbox           => mailbox_class.new,
+        :mailbox           => mailbox.build,
         :proxy_class       => proxy_class,
         :task_class        => task_class,
         :exit_handler      => exit_handler,
-        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil
+        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil,
+        :receiver_block_executions => receiver_block_executions
       }
     end
 
     def ===(other)
       other.kind_of? self
     end
+
+    def mailbox
+      @mailbox_factory ||= MailboxFactory.new(self)
+    end
+
+    class MailboxFactory
+      attr_accessor :class, :max_size
+
+      def initialize(actor)
+        @actor    = actor
+        @class    = nil
+        @max_size = nil
+      end
+
+      def build
+        mailbox = mailbox_class.new
+        mailbox.max_size = @max_size
+        mailbox
+      end
+
+      private
+      def mailbox_class
+        @class || (@actor.superclass.respond_to?(:mailbox_class) && @actor.superclass.mailbox_class) || Celluloid::Mailbox
+      end
+    end
   end
 
   # These are methods we don't want added to the Celluloid singleton but to be
@@ -265,6 +315,16 @@ module Celluloid
       @celluloid_owner != Thread.current[:celluloid_actor]
     end
 
+    def tap
+      yield current_actor
+      current_actor
+    end
+
+    # Obtain the name of the current actor
+    def name
+      Actor.name
+    end
+
     def inspect
       str = "#<"
 
@@ -291,7 +351,7 @@ module Celluloid
   # directly inside of all classes that include Celluloid
   #
 
-  # Raise an exception in caller context, but stay running
+  # Raise an exception in sender context, but stay running
   def abort(cause)
     cause = case cause
       when String then RuntimeError.new(cause)
@@ -326,11 +386,6 @@ module Celluloid
     Thread.current[:celluloid_chain_id]
   end
 
-  # Obtain the name of the current actor
-  def name
-    Actor.name
-  end
-
   # Obtain the running tasks for this actor
   def tasks
     Thread.current[:celluloid_actor].tasks.to_a
@@ -377,7 +432,7 @@ module Celluloid
     if actor
       actor.receive(timeout, &block)
     else
-      Thread.mailbox.receive(timeout, &block)
+      Celluloid.mailbox.receive(timeout, &block)
     end
   end
 
@@ -414,7 +469,7 @@ module Celluloid
   end
 
   # Perform a blocking or computationally intensive action inside an
-  # asynchronous thread pool, allowing the caller to continue processing other
+  # asynchronous thread pool, allowing the sender to continue processing other
   # messages in its mailbox in the meantime
   def defer(&block)
     # This implementation relies on the present implementation of
@@ -424,20 +479,12 @@ module Celluloid
 
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
-    if meth
-      Actor.async Thread.current[:celluloid_actor].mailbox, meth, *args, &block
-    else
-      Thread.current[:celluloid_actor].proxy.async
-    end
+    Thread.current[:celluloid_actor].proxy.async meth, *args, &block
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
-    if meth
-      Actor.future Thread.current[:celluloid_actor].mailbox, meth, *args, &block
-    else
-      Thread.current[:celluloid_actor].proxy.future
-    end
+    Thread.current[:celluloid_actor].proxy.future meth, *args, &block
   end
 end
 
@@ -445,6 +492,7 @@ require 'celluloid/version'
 
 require 'celluloid/calls'
 require 'celluloid/condition'
+require 'celluloid/thread'
 require 'celluloid/core_ext'
 require 'celluloid/cpu_counter'
 require 'celluloid/fiber'
@@ -453,6 +501,7 @@ require 'celluloid/internal_pool'
 require 'celluloid/links'
 require 'celluloid/logger'
 require 'celluloid/mailbox'
+require 'celluloid/evented_mailbox'
 require 'celluloid/method'
 require 'celluloid/receivers'
 require 'celluloid/registry'
@@ -465,9 +514,11 @@ require 'celluloid/thread_handle'
 require 'celluloid/uuid'
 
 require 'celluloid/proxies/abstract_proxy'
+require 'celluloid/proxies/sync_proxy'
 require 'celluloid/proxies/actor_proxy'
 require 'celluloid/proxies/async_proxy'
 require 'celluloid/proxies/future_proxy'
+require 'celluloid/proxies/block_proxy'
 
 require 'celluloid/actor'
 require 'celluloid/future'
@@ -483,3 +534,4 @@ require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
 Celluloid.task_class = Celluloid::TaskFiber
 Celluloid.logger     = Logger.new(STDERR)
 Celluloid.shutdown_timeout = 10
+Celluloid.register_shutdown

data/lib/celluloid/actor.rb

@@ -10,7 +10,7 @@ module Celluloid
   # A timeout occured before the given request could complete
   class TimeoutError < StandardError; end
 
-  # The caller made an error, not the current actor
+  # The sender made an error, not the current actor
   class AbortError < StandardError
     attr_reader :cause
 
@@ -27,7 +27,7 @@ module Celluloid
   # normal Ruby objects wrapped in threads which communicate with asynchronous
   # messages.
   class Actor
-    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
+    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name, :locals
 
     class << self
       extend Forwardable
@@ -58,42 +58,29 @@ module Celluloid
 
       # 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
-
-        Celluloid.suspend(:callwait, call).value
+        proxy = SyncProxy.new(mailbox, "UnknownClass")
+        proxy.method_missing(meth, *args, &block)
       end
 
       # Invoke a method asynchronously on an actor via its mailbox
       def async(mailbox, meth, *args, &block)
-        begin
-          mailbox << AsyncCall.new(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
+        proxy = AsyncProxy.new(mailbox, "UnknownClass")
+        proxy.method_missing(meth, *args, &block)
       end
 
       # 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
+        proxy = FutureProxy.new(mailbox, "UnknownClass")
+        proxy.method_missing(meth, *args, &block)
       end
 
       # Obtain all running actors in the system
       def all
         actors = []
         Thread.list.each do |t|
-          actor = t[:celluloid_actor]
-          actors << actor.proxy if actor and actor.respond_to?(:proxy)
+          next unless t.celluloid?
+          next if t.task
+          actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
         end
         actors
       end
@@ -142,8 +129,8 @@ module Celluloid
       end
 
       # Wait for an actor to terminate
-      def join(actor)
-        actor.thread.join
+      def join(actor, timeout = nil)
+        actor.thread.join(timeout)
         actor
       end
     end
@@ -154,6 +141,7 @@ module Celluloid
       @mailbox      = options[:mailbox] || Mailbox.new
       @exit_handler = options[:exit_handler]
       @exclusives   = options[:exclusive_methods]
+      @receiver_block_executions = options[:receiver_block_executions]
       @task_class   = options[:task_class] || Celluloid.task_class
 
       @tasks     = TaskSet.new
@@ -164,10 +152,10 @@ module Celluloid
       @running   = true
       @exclusive = false
       @name      = nil
+      @locals    = {}
 
       @thread = ThreadHandle.new do
-        Thread.current[:celluloid_actor]   = self
-        Thread.current[:celluloid_mailbox] = @mailbox
+        setup_thread
         run
       end
 
@@ -175,6 +163,11 @@ module Celluloid
       @subject.instance_variable_set(OWNER_IVAR, self)
     end
 
+    def setup_thread
+      Thread.current[:celluloid_actor]   = self
+      Thread.current[:celluloid_mailbox] = @mailbox
+    end
+
     # Run the actor loop
     def run
       begin
@@ -323,8 +316,20 @@ module Celluloid
       when SystemEvent
         handle_system_event message
       when Call
-        task(:message_handler, message.method) { message.dispatch(@subject) }
-      when Response
+        task(:call, message.method) {
+          if @receiver_block_executions && meth = message.method
+            if meth == :__send__
+              meth = message.arguments.first
+            end
+            if @receiver_block_executions.include?(meth.to_sym)
+              message.execute_block_on_receiver
+            end
+          end
+          message.dispatch(@subject)
+        }
+      when BlockCall
+        task(:invoke_block) { message.dispatch }
+      when BlockResponse, Response
         message.dispatch
       else
         @receivers.handle_message(message)

data/lib/celluloid/autostart.rb

@@ -1,16 +1,3 @@
 require 'celluloid'
 
 Celluloid.boot
-
-# Terminate all actors at exit
-at_exit do
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
-    # workaround for MRI bug losing exit status in at_exit block
-    # http://bugs.ruby-lang.org/issues/5218
-    exit_status = $!.status if $!.is_a?(SystemExit)
-    Celluloid.shutdown
-    exit exit_status if exit_status
-  else
-    Celluloid.shutdown
-  end
-end

data/lib/celluloid/calls.rb

@@ -4,19 +4,33 @@ module Celluloid
     attr_reader :method, :arguments, :block
 
     def initialize(method, arguments = [], block = nil)
-      @method, @arguments, @block = method, arguments, block
+      @method, @arguments = method, arguments
+      if block
+        if Celluloid.exclusive?
+          # FIXME: nicer exception
+          raise "Cannot execute blocks on sender in exclusive mode"
+        end
+        @block = BlockProxy.new(self, Celluloid.mailbox, block)
+      else
+        @block = nil
+      end
+    end
+
+    def execute_block_on_receiver
+      @block && @block.execution = :receiver
     end
 
     def dispatch(obj)
-      obj.public_send(@method, *@arguments, &@block)
+      _block = @block && @block.to_proc
+      obj.public_send(@method, *@arguments, &_block)
     rescue NoMethodError => ex
-      # Abort if the caller made a mistake
+      # Abort if the sender made a mistake
       raise AbortError.new(ex) unless obj.respond_to? @method
 
       # Otherwise something blew up. Crash this actor
       raise
     rescue ArgumentError => ex
-      # Abort if the caller made a mistake
+      # Abort if the sender made a mistake
       begin
         arity = obj.method(@method).arity
       rescue NameError
@@ -34,26 +48,16 @@ module Celluloid
       # Otherwise something blew up. Crash this actor
       raise
     end
-
-    def wait
-      loop do
-        message = Thread.mailbox.receive do |msg|
-          msg.respond_to?(:call) and msg.call == self
-        end
-        break message unless message.is_a?(SystemEvent)
-        Thread.current[:celluloid_actor].handle_system_event(message)
-      end
-    end
   end
 
   # Synchronous calls wait for a response
   class SyncCall < Call
-    attr_reader :caller, :task, :chain_id
+    attr_reader :sender, :task, :chain_id
 
-    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Thread.current[:celluloid_chain_id])
+    def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Thread.current[:celluloid_chain_id])
       super(method, arguments, block)
 
-      @caller   = caller
+      @sender   = sender
       @task     = task
       @chain_id = chain_id || Celluloid.uuid
     end
@@ -64,11 +68,11 @@ module Celluloid
       respond SuccessResponse.new(self, result)
     rescue Exception => ex
       # Exceptions that occur during synchronous calls are reraised in the
-      # context of the caller
+      # context of the sender
       respond ErrorResponse.new(self, ex)
 
-      # Aborting indicates a protocol error on the part of the caller
-      # It should crash the caller, but the exception isn't reraised
+      # Aborting indicates a protocol error on the part of the sender
+      # It should crash the sender, but the exception isn't reraised
       # Otherwise, it's a bug in this actor and should be reraised
       raise unless ex.is_a?(AbortError)
     ensure
@@ -81,11 +85,36 @@ module Celluloid
     end
 
     def respond(message)
-      @caller << message
+      @sender << message
     rescue MailboxError
-      # It's possible the caller exited or crashed before we could send a
+      # It's possible the sender exited or crashed before we could send a
       # response to them.
     end
+
+    def value
+      Celluloid.suspend(:callwait, self).value
+    end
+
+    def wait
+      loop do
+        message = Celluloid.mailbox.receive do |msg|
+          msg.respond_to?(:call) and msg.call == self
+        end
+
+        if message.is_a?(SystemEvent)
+          Thread.current[:celluloid_actor].handle_system_event(message)
+        else
+          # FIXME: add check for receiver block execution
+          if message.respond_to?(:value)
+            # FIXME: disable block execution if on :sender and (exclusive or outside of task)
+            # probably now in Call
+            break message
+          else
+            message.dispatch
+          end
+        end
+      end
+    end
   end
 
   # Asynchronous calls don't wait for a response
@@ -95,7 +124,7 @@ module Celluloid
       Thread.current[:celluloid_chain_id] = Celluloid.uuid
       super(obj)
     rescue AbortError => ex
-      # Swallow aborted async calls, as they indicate the caller made a mistake
+      # Swallow aborted async calls, as they indicate the sender made a mistake
       Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
     ensure
       Thread.current[:celluloid_chain_id] = nil
@@ -103,4 +132,23 @@ module Celluloid
 
   end
 
+  class BlockCall
+    def initialize(block_proxy, sender, arguments, task = Thread.current[:celluloid_task])
+      @block_proxy = block_proxy
+      @sender = sender
+      @arguments = arguments
+      @task = task
+    end
+    attr_reader :task
+
+    def call
+      @block_proxy.call
+    end
+
+    def dispatch
+      response = @block_proxy.block.call(*@arguments)
+      @sender << BlockResponse.new(self, response)
+    end
+  end
+
 end