celluloid 0.12.0 → 0.13.0

data/README.md

@@ -1,7 +1,10 @@
 ![Celluloid](https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png)
 =========
+[![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)
 
 > "I thought of objects being like biological cells and/or individual
 > computers on a network, only able to communicate with messages"
@@ -44,7 +47,7 @@ features which make concurrent programming simple, easy, and fun:
   The central idea: have you tried turning it off and on again? Celluloid
   takes care of rebooting subcomponents of your application when they crash,
   whether it's a single actor, or large (potentially multi-tiered) groups of
-  actors that are all interdependent. This means rather that worrying about
+  actors that are all interdependent. This means rather than worrying about
   rescuing every last exception, you can just sit back, relax, and let parts
   of your program crash, knowing Celluloid will automatically reboot them in
   a clean state. Celluloid provides its own implementation of the core
@@ -63,19 +66,34 @@ features which make concurrent programming simple, easy, and fun:
 
 You can also build distributed systems with Celluloid using its
 [sister project DCell](https://github.com/celluloid/dcell). Evented IO similar
-to EventMachine (with a synchronous API) is available through the
-[Celluloid::IO](https://github.com/celluloid/celluloid-io) library.
-
-[Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
-for more detailed documentation and usage notes.
+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)
 or visit us on IRC at #celluloid on freenode
 
+### Is it any good?
+
+[Yes](http://news.ycombinator.com/item?id=3067434)
+
 ### Is It "Production Ready™"?
 
 Yes, many users are now running Celluloid in production by using
-[Sidekiq](https://github.com/mperham/sidekiq)
+[Sidekiq](http://sidekiq.org) and [Adhearsion](http://adhearsion.com/)
+
+Documentation
+-------------
+
+[Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
+for more detailed documentation and usage notes.
+
+The following API documentation is also available:
+
+* [YARD API documentation](http://rubydoc.info/gems/celluloid/frames)
+* [Celluloid module (primary API)](http://rubydoc.info/gems/celluloid/Celluloid)
+* [Celluloid class methods](http://rubydoc.info/gems/celluloid/Celluloid/ClassMethods)
+* [All Celluloid classes](http://rubydoc.info/gems/celluloid/index)
 
 Installation
 ------------
@@ -92,25 +110,20 @@ Or install it yourself as:
 
     $ gem install celluloid
 
-Inside of your Ruby program do:
-
-    require 'celluloid'
+Inside of your Ruby program, require Celluloid with:
 
-...to pull it in as a dependency.
+    require 'celluloid/autostart'
 
 Supported Platforms
 -------------------
 
-Celluloid works on Ruby 1.9.3, JRuby 1.6, and Rubinius 2.0. JRuby or Rubinius
-are the preferred platforms as they support true thread-level parallelism when
-executing Ruby code, whereas MRI/YARV is constrained by a global interpreter
-lock (GIL) and can only execute one thread at a time.
+Celluloid works on Ruby 1.9.3, 2.0.0, JRuby 1.6+, and Rubinius 2.0.
 
-Celluloid requires Ruby 1.9 mode on all interpreters. This works out of the
-box on MRI/YARV, and requires the following flags elsewhere:
+JRuby or Rubinius are the preferred platforms as they support true thread-level
+parallelism when executing Ruby code, whereas MRI/YARV is constrained by a global
+interpreter lock (GIL) and can only execute one thread at a time.
 
-* JRuby: --1.9 command line option, or JRUBY_OPTS=--1.9 environment variable
-* rbx: -X19 command line option
+Celluloid requires Ruby 1.9 mode on all interpreters.
 
 Additional Reading
 ------------------
@@ -122,12 +135,12 @@ Contributing to Celluloid
 -------------------------
 
 * Fork this repository on github
-* Make your changes and send me a pull request
-* If I like them I'll merge them
-* If I've accepted a patch, feel free to ask for commit access
+* Make your changes and send us a pull request
+* If we like them we'll merge them
+* If we've accepted a patch, feel free to ask for commit access
 
 License
 -------
 
-Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
+Copyright (c) 2013 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.

data/lib/celluloid/actor.rb

@@ -21,6 +21,7 @@ module Celluloid
   end
 
   LINKING_TIMEOUT = 5 # linking times out after 5 seconds
+  OWNER_IVAR = :@celluloid_owner # reference to owning actor
 
   # Actors are Celluloid's concurrency primitive. They're implemented as
   # normal Ruby objects wrapped in threads which communicate with asynchronous
@@ -43,14 +44,14 @@ module Celluloid
 
       # Obtain the current actor
       def current
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.proxy
       end
 
       # Obtain the name of the current actor
       def name
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.name
       end
@@ -65,21 +66,7 @@ module Celluloid
           raise DeadActorError, "attempted to call a dead actor"
         end
 
-        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 or exclusive, so block
-          response = loop do
-            message = Thread.mailbox.receive do |msg|
-              msg.respond_to?(:call) and msg.call == call
-            end
-            break message unless message.is_a?(SystemEvent)
-            Thread.current[:actor].handle_system_event(message)
-          end
-
-          response.value
-        end
+        Celluloid.suspend(:callwait, call).value
       end
 
       # Invoke a method asynchronously on an actor via its mailbox
@@ -105,7 +92,7 @@ module Celluloid
       def all
         actors = []
         Thread.list.each do |t|
-          actor = t[:actor]
+          actor = t[:celluloid_actor]
           actors << actor.proxy if actor and actor.respond_to?(:proxy)
         end
         actors
@@ -114,25 +101,25 @@ module Celluloid
       # Watch for exit events from another actor
       def monitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:actor].linking_request(actor, :link)
+        Thread.current[:celluloid_actor].linking_request(actor, :link)
       end
 
       # Stop waiting for exit events from another actor
       def unmonitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:actor].linking_request(actor, :unlink)
+        Thread.current[:celluloid_actor].linking_request(actor, :unlink)
       end
 
       # Link to another actor
       def link(actor)
         monitor actor
-        Thread.current[:actor].links << actor
+        Thread.current[:celluloid_actor].links << actor
       end
 
       # Unlink from another actor
       def unlink(actor)
         unmonitor actor
-        Thread.current[:actor].links.delete actor
+        Thread.current[:celluloid_actor].links.delete actor
       end
 
       # Are we monitoring the given actor?
@@ -142,7 +129,7 @@ module Celluloid
 
       # Are we bidirectionally linked to the given actor?
       def linked_to?(actor)
-        monitoring?(actor) && Thread.current[:actor].links.include?(actor)
+        monitoring?(actor) && Thread.current[:celluloid_actor].links.include?(actor)
       end
 
       # Forcibly kill a given actor
@@ -169,7 +156,7 @@ module Celluloid
       @exclusives   = options[:exclusive_methods]
       @task_class   = options[:task_class] || Celluloid.task_class
 
-      @tasks     = Set.new
+      @tasks     = TaskSet.new
       @links     = Links.new
       @signals   = Signals.new
       @receivers = Receivers.new
@@ -179,12 +166,13 @@ module Celluloid
       @name      = nil
 
       @thread = ThreadHandle.new do
-        Thread.current[:actor]   = self
-        Thread.current[:mailbox] = @mailbox
+        Thread.current[:celluloid_actor]   = self
+        Thread.current[:celluloid_mailbox] = @mailbox
         run
       end
 
-      @proxy = ActorProxy.new(self)
+      @proxy = (options[:proxy_class] || ActorProxy).new(self)
+      @subject.instance_variable_set(OWNER_IVAR, self)
     end
 
     # Run the actor loop
@@ -221,23 +209,31 @@ module Celluloid
 
     # Execute a code block in exclusive mode.
     def exclusive
-      @exclusive = true
-      yield
-    ensure
-      @exclusive = false
+      if @exclusive
+        yield
+      else
+        begin
+          @exclusive = true
+          yield
+        ensure
+          @exclusive = false
+        end
+      end
     end
 
     # Perform a linking request with another actor
     def linking_request(receiver, type)
       exclusive do
         start_time = Time.now
-
         receiver.mailbox << LinkingRequest.new(Actor.current, type)
         system_events = []
+
         loop do
           wait_interval = start_time + LINKING_TIMEOUT - Time.now
           message = @mailbox.receive(wait_interval) do |msg|
-            msg.is_a?(LinkingResponse) && msg.actor == receiver && msg.type == type
+            msg.is_a?(LinkingResponse) &&
+            msg.actor.mailbox.address == receiver.mailbox.address &&
+            msg.type == type
           end
 
           case message
@@ -300,15 +296,25 @@ module Celluloid
       @timers.every(interval) { task(:timer, &block) }
     end
 
+    class Sleeper
+      def initialize(timers, interval)
+        @timers = timers
+        @interval = interval
+      end
+
+      def before_suspend(task)
+        @timers.after(@interval) { task.resume }
+      end
+
+      def wait
+        Kernel.sleep(@interval)
+      end
+    end
+
     # Sleep for the given amount of time
     def sleep(interval)
-      if Celluloid.exclusive?
-        Kernel.sleep(interval)
-      else
-        task = Task.current
-        @timers.after(interval) { task.resume }
-        Task.suspend :sleeping
-      end
+      sleeper = Sleeper.new(@timers, interval)
+      Celluloid.suspend(:sleeping, sleeper)
     end
 
     # Handle standard low-priority messages
@@ -337,11 +343,15 @@ module Celluloid
         @name = event.name
       when TerminationRequest
         @running = false
+      when SignalConditionRequest
+        event.call
       end
     end
 
     # Handle exit events received by this actor
     def handle_exit_event(event)
+      @links.delete event.actor
+
       # Run the exit handler if available
       return @subject.send(@exit_handler, event.actor, event.reason) if @exit_handler
 
@@ -363,14 +373,24 @@ module Celluloid
       run_finalizer
       cleanup exit_event
     ensure
-      Thread.current[:actor]   = nil
-      Thread.current[:mailbox] = nil
+      Thread.current[:celluloid_actor]   = nil
+      Thread.current[:celluloid_mailbox] = nil
     end
 
     # Run the user-defined finalizer, if one is set
     def run_finalizer
-      return unless @subject.respond_to? :finalize
-      task(:finalizer, :finalize) { @subject.finalize }
+      # FIXME: remove before Celluloid 1.0
+      if @subject.respond_to?(:finalize) && @subject.class.finalizer != :finalize
+        Logger.warn("DEPRECATION WARNING: #{@subject.class}#finalize is deprecated and will be removed in Celluloid 1.0. " +
+          "Define finalizers with '#{@subject.class}.finalizer :callback.'")
+
+        task(:finalizer, :finalize) { @subject.finalize }
+      end
+
+      finalizer = @subject.class.finalizer
+      if finalizer && @subject.respond_to?(finalizer, true)
+        task(:finalizer, :finalize) { @subject.__send__(finalizer) }
+      end
     rescue => ex
       Logger.crash("#{@subject.class}#finalize crashed!", ex)
     end
@@ -378,7 +398,14 @@ module Celluloid
     # Clean up after this actor
     def cleanup(exit_event)
       @mailbox.shutdown
-      @links.send_event exit_event
+      @links.each do |actor|
+        begin
+          actor.mailbox << exit_event
+        rescue MailboxError
+          # We're exiting/crashing, they're dead. Give up :(
+        end
+      end
+
       tasks.each { |task| task.terminate }
     rescue => ex
       Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
@@ -386,10 +413,10 @@ module Celluloid
 
     # Run a method inside a task unless it's exclusive
     def task(task_type, method_name = nil, &block)
-      if @exclusives && (@exclusives == :all || @exclusives.include?(method_name))
+      if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
         exclusive { block.call }
       else
-        @task_class.new(:message_handler, &block).resume
+        @task_class.new(task_type, &block).resume
       end
     end
   end

data/lib/celluloid/autostart.rb

@@ -0,0 +1,16 @@
+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

@@ -7,70 +7,72 @@ module Celluloid
       @method, @arguments, @block = method, arguments, block
     end
 
-    def check_signature(obj)
-      unless obj.respond_to? @method
-        raise NoMethodError, "undefined method `#{@method}' for #{obj.to_s}"
-      end
+    def dispatch(obj)
+      obj.public_send(@method, *@arguments, &@block)
+    rescue NoMethodError => ex
+      # Abort if the caller 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
       begin
         arity = obj.method(@method).arity
       rescue NameError
-        # If the object claims it responds to a method, but it doesn't exist,
-        # then we have to assume method_missing will do what it says
-        @arguments.unshift(@method)
-        @method = :method_missing
-        return
+        # In theory this shouldn't happen, but just in case
+        raise AbortError.new(ex)
       end
 
       if arity >= 0
-        if arguments.size != arity
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{arity})"
-        end
+        raise AbortError.new(ex) if @arguments.size != arity
       elsif arity < -1
         mandatory_args = -arity - 1
-        if arguments.size < mandatory_args
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{mandatory_args})"
+        raise AbortError.new(ex) if arguments.size < mandatory_args
+      end
+
+      # 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
+    attr_reader :caller, :task, :chain_id
 
-    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:task])
+    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Thread.current[:celluloid_chain_id])
       super(method, arguments, block)
-      @caller = caller
-      @task = task
+
+      @caller   = caller
+      @task     = task
+      @chain_id = chain_id || Celluloid.uuid
     end
 
     def dispatch(obj)
-      begin
-        check_signature(obj)
-      rescue => ex
-        respond ErrorResponse.new(self, 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)
-
-        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
-
+      Thread.current[:celluloid_chain_id] = @chain_id
+      result = super(obj)
       respond SuccessResponse.new(self, result)
+    rescue Exception => ex
+      # Exceptions that occur during synchronous calls are reraised in the
+      # context of the caller
+      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
+      # Otherwise, it's a bug in this actor and should be reraised
+      raise unless ex.is_a?(AbortError)
+    ensure
+      Thread.current[:celluloid_chain_id] = nil
     end
 
     def cleanup
@@ -88,19 +90,17 @@ module Celluloid
 
   # Asynchronous calls don't wait for a response
   class AsyncCall < Call
-    def dispatch(obj)
-      begin
-        check_signature(obj)
-      rescue Exception => ex
-        Logger.crash("#{obj.class}: async call `#{@method}' failed!", ex)
-        return
-      end
 
-      obj.send(@method, *@arguments, &@block)
+    def dispatch(obj)
+      Thread.current[:celluloid_chain_id] = Celluloid.uuid
+      super(obj)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
-      Logger.crash("#{obj.class}: async call `#{@method}' aborted!", ex.cause)
+      Logger.debug("#{obj.class}: async call `#@method` aborted!\n#{Logger.format_exception(ex.cause)}")
+    ensure
+      Thread.current[:celluloid_chain_id] = nil
     end
+
   end
-end
 
+end

data/lib/celluloid/condition.rb

@@ -0,0 +1,70 @@
+module Celluloid
+  class ConditionError < StandardError; end
+
+  # ConditionVariable-like signaling between tasks and actors
+  class Condition
+    attr_reader :owner
+
+    def initialize
+      @mutex = Mutex.new
+      @owner = Thread.current[:celluloid_actor]
+      @tasks = []
+    end
+
+    # Wait for the given signal and return the associated value
+    def wait
+      raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
+
+      @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
+      end
+
+      result = Task.suspend :condwait
+      raise result if result.is_a? ConditionError
+      result
+    end
+
+    # 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)
+        else
+          Logger.debug("Celluloid::Condition signaled spuriously")
+        end
+      end
+    end
+
+    # 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.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

@@ -6,7 +6,7 @@ class Thread
 
   # Retrieve the mailbox for the current thread or lazily initialize it
   def self.mailbox
-    current[:mailbox] ||= Celluloid::Mailbox.new
+    current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
   end
 
   # Receive a message either as an actor or through the local mailbox

data/lib/celluloid/cpu_counter.rb

@@ -6,7 +6,11 @@ module Celluloid
     when 'darwin'
       @cores = Integer(`sysctl hw.ncpu`[/\d+/])
     when 'linux'
-      @cores = File.read("/proc/cpuinfo").scan(/core id\s+: \d+/).uniq.size
+      @cores = if File.exists?("/sys/devices/system/cpu/present")
+        File.read("/sys/devices/system/cpu/present").split('-').last.to_i+1
+      else
+        Dir["/sys/devices/system/cpu/cpu*"].select { |n| n=~/cpu\d+/ }.count
+      end
     when 'mingw', 'mswin'
       @cores = Integer(`SET NUMBER_OF_PROCESSORS`[/\d+/])
     else
@@ -16,3 +20,5 @@ module Celluloid
     def self.cores; @cores; end
   end
 end
+
+