celluloid 0.13.0 → 0.14.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83a01356fe7e144f11c0ac9db25951850f53c9b4
+  data.tar.gz: 243e2915cef408cf97229f8ec0a512bfb2524fb8
+SHA512:
+  metadata.gz: 60e75d013b08ff7101ea6280b31bd5976ba097e821880e3d6d9b935580c8515d05d8619bc6a3df7be1d2733366d97b482a3668443e59c3c9e397bc6a14e46c75
+  data.tar.gz: 3e9fe0851276289183c6ca52e72bc545dc174831d325d78a9682f63087c4f54ff3b6f454babf4b091641a163235f953e02bbf656cfbdce4e093ec35df831e167

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/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
 
@@ -58,42 +58,28 @@ 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? && t.role == :actor
+          actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
         end
         actors
       end
@@ -142,8 +128,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 +140,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
@@ -165,9 +152,8 @@ module Celluloid
       @exclusive = false
       @name      = nil
 
-      @thread = ThreadHandle.new do
-        Thread.current[:celluloid_actor]   = self
-        Thread.current[:celluloid_mailbox] = @mailbox
+      @thread = ThreadHandle.new(:actor) do
+        setup_thread
         run
       end
 
@@ -175,6 +161,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 +314,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

data/lib/celluloid/condition.rb

@@ -3,11 +3,30 @@ module Celluloid
 
   # ConditionVariable-like signaling between tasks and actors
   class Condition
+    class Waiter
+      def initialize(condition, task, mailbox)
+        @condition = condition
+        @task = task
+        @mailbox = mailbox
+      end
+      attr_reader :condition, :task
+
+      def <<(message)
+        @mailbox << message
+      end
+
+      def wait
+        message = @mailbox.receive do |msg|
+          msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
+        end
+        message.value
+      end
+    end
+
     attr_reader :owner
 
     def initialize
       @mutex = Mutex.new
-      @owner = Thread.current[:celluloid_actor]
       @tasks = []
     end
 
@@ -15,14 +34,18 @@ module Celluloid
     def wait
       raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
+      if Thread.current[:celluloid_actor]
+        task = Task.current
+      else
+        task = Thread.current
+      end
+      waiter = Waiter.new(self, task, Celluloid.mailbox)
+
       @mutex.synchronize do
-        actor = Thread.current[:celluloid_actor]
-        raise ConditionError, "can't wait for conditions outside actors" unless actor
-        raise ConditionError, "can't wait unless owner" unless actor == @owner
-        @tasks << Task.current
+        @tasks << waiter
       end
 
-      result = Task.suspend :condwait
+      result = Celluloid.suspend :condwait, waiter
       raise result if result.is_a? ConditionError
       result
     end
@@ -30,10 +53,8 @@ module Celluloid
     # Send a signal to the first task waiting on this condition
     def signal(value = nil)
       @mutex.synchronize do
-        raise ConditionError, "no owner for this condition" unless @owner
-
-        if task = @tasks.shift
-          @owner.mailbox << SignalConditionRequest.new(task, value)
+        if waiter = @tasks.shift
+          waiter << SignalConditionRequest.new(waiter.task, value)
         else
           Logger.debug("Celluloid::Condition signaled spuriously")
         end
@@ -43,28 +64,11 @@ module Celluloid
     # Broadcast a value to all waiting tasks
     def broadcast(value = nil)
       @mutex.synchronize do
-        raise ConditionError, "no owner for this condition" unless @owner
-
-        @tasks.each { |task| @owner.mailbox << SignalConditionRequest.new(task, value) }
+        @tasks.each { |waiter| waiter << SignalConditionRequest.new(waiter.task, value) }
         @tasks.clear
       end
     end
 
-    # Change the owner of this condition
-    def owner=(actor)
-      @mutex.synchronize do
-        if @owner != actor
-          @tasks.each do |task|
-            ex = ConditionError.new("ownership changed")
-            @owner.mailbox << SignalConditionRequest.new(task, ex)
-          end
-          @tasks.clear
-        end
-
-        @owner = actor
-      end
-    end
-
     alias_method :inspect, :to_s
   end
 end

data/lib/celluloid/core_ext.rb

@@ -1,20 +1,9 @@
 require 'celluloid/fiber'
 
-# Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
 class Thread
   attr_accessor :uuid_counter, :uuid_limit
 
-  # Retrieve the mailbox for the current thread or lazily initialize it
-  def self.mailbox
-    current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
+  def celluloid?
+    false
   end
-
-  # Receive a message either as an actor or through the local mailbox
-  def self.receive(timeout = nil, &block)
-    if Celluloid.actor?
-      Celluloid.receive(timeout, &block)
-    else
-      mailbox.receive(timeout, &block)
-    end
-  end
-end
+end

data/lib/celluloid/cpu_counter.rb

@@ -12,7 +12,7 @@ module Celluloid
         Dir["/sys/devices/system/cpu/cpu*"].select { |n| n=~/cpu\d+/ }.count
       end
     when 'mingw', 'mswin'
-      @cores = Integer(`SET NUMBER_OF_PROCESSORS`[/\d+/])
+      @cores = Integer(ENV["NUMBER_OF_PROCESSORS"][/\d+/])
     else
       @cores = nil
     end

data/lib/celluloid/evented_mailbox.rb

@@ -0,0 +1,82 @@
+module Celluloid
+  # An alternative implementation of Celluloid::Mailbox using Reactor
+  class EventedMailbox < Celluloid::Mailbox
+    attr_reader :reactor
+
+    def initialize(reactor_class)
+      super()
+      # @condition won't be used in the class.
+      @reactor = reactor_class.new
+    end
+
+    # Add a message to the Mailbox
+    def <<(message)
+      @mutex.lock
+      begin
+        if mailbox_full
+          Logger.debug "Discarded message: #{message}"
+          return
+        end
+        if message.is_a?(SystemEvent)
+          # Silently swallow system events sent to dead actors
+          return if @dead
+
+          # SystemEvents are high priority messages so they get added to the
+          # head of our message queue instead of the end
+          @messages.unshift message
+        else
+          raise MailboxError, "dead recipient" if @dead
+          @messages << message
+        end
+
+        current_actor = Thread.current[:celluloid_actor]
+        @reactor.wakeup unless current_actor && current_actor.mailbox == self
+      rescue IOError
+        raise MailboxError, "dead recipient"
+      ensure
+        @mutex.unlock rescue nil
+      end
+      nil
+    end
+
+    # Receive a message from the Mailbox
+    def receive(timeout = nil, &block)
+      message = next_message(block)
+
+      until 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
+
+        @reactor.run_once(wait_interval)
+        message = next_message(block)
+      end
+
+      message
+    rescue IOError
+      shutdown # force shutdown of the mailbox
+      raise MailboxShutdown, "mailbox shutdown called during receive"
+    end
+
+    # Obtain the next message from the mailbox that matches the given block
+    def next_message(block)
+      @mutex.lock
+      begin
+        super(&block)
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    # Cleanup any IO objects this Mailbox may be using
+    def shutdown
+      @reactor.shutdown
+      super
+    end
+  end
+end

data/lib/celluloid/fsm.rb

@@ -62,6 +62,7 @@ module Celluloid
     # Be kind and call super if you must redefine initialize
     def initialize(actor = nil)
       @state = self.class.default_state
+      @delayed_transition = nil
       @actor = actor
       @actor ||= Celluloid.current_actor if Celluloid.actor?
     end
@@ -166,6 +167,7 @@ module Celluloid
 
       def initialize(name, transitions = nil, &block)
         @name, @block = name, block
+        @transitions = nil
         @transitions = Array(transitions).map { |t| t.to_sym } if transitions
       end
 

data/lib/celluloid/future.rb

@@ -4,38 +4,30 @@ module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
   class Future
+    def self.new(*args, &block)
+      return super unless block
+
+      future = new
+      Celluloid.internal_pool.get do
+        Thread.current.role = :future
+        begin
+          call = SyncCall.new(future, :call, args)
+          call.dispatch(block)
+        rescue
+          # Exceptions in blocks will get raised when the value is retrieved
+        end
+      end
+      future
+    end
+
     attr_reader :address
-    
-    # Create a future bound to a given receiver, or with a block to compute
-    def initialize(*args, &block)
+
+    def initialize
       @address = Celluloid.uuid
       @mutex = Mutex.new
       @ready = false
       @result = nil
       @forwards = nil
-
-      if block
-        @call = SyncCall.new(self, :call, args)
-        Celluloid.internal_pool.get do
-          begin
-            @call.dispatch(block)
-          rescue
-            # Exceptions in blocks will get raised when the value is retrieved
-          end
-        end
-      else
-        @call = nil
-      end
-    end
-
-    # Execute the given method in future context
-    def execute(receiver, method, args, block)
-      @mutex.synchronize do
-        raise "already calling" if @call
-        @call = SyncCall.new(self, method, args, block)
-      end
-
-      receiver << @call
     end
 
     # Check if this future has a value yet
@@ -49,7 +41,6 @@ module Celluloid
 
       begin
         @mutex.lock
-        raise "no call requested" unless @call
 
         if @ready
           ready = true
@@ -57,11 +48,11 @@ module Celluloid
         else
           case @forwards
           when Array
-            @forwards << Thread.mailbox
+            @forwards << Celluloid.mailbox
           when NilClass
-            @forwards = Thread.mailbox
+            @forwards = Celluloid.mailbox
           else
-            @forwards = [@forwards, Thread.mailbox]
+            @forwards = [@forwards, Celluloid.mailbox]
           end
         end
       ensure
@@ -69,7 +60,7 @@ module Celluloid
       end
 
       unless ready
-        result = Thread.receive(timeout) do |msg|
+        result = Celluloid.receive(timeout) do |msg|
           msg.is_a?(Future::Result) && msg.future == self
         end
       end

data/lib/celluloid/internal_pool.rb

@@ -10,6 +10,10 @@ module Celluloid
       @mutex = Mutex.new
       @busy_size = @idle_size = 0
 
+      reset
+    end
+
+    def reset
       # TODO: should really adjust this based on usage
       @max_idle = 16
     end
@@ -74,6 +78,15 @@ module Celluloid
         thread[key] = nil
       end
     end
+
+    def shutdown
+      @mutex.synchronize do
+        @max_idle = 0
+        @pool.each do |thread|
+          thread[:celluloid_queue] << nil
+        end
+      end
+    end
   end
 
   self.internal_pool = InternalPool.new