celluloid 0.13.0.pre → 0.13.0.pre2

data/README.md

@@ -1,8 +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"
@@ -71,6 +73,10 @@ 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
@@ -104,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
 ------------------
@@ -134,9 +135,9 @@ 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
 -------

data/lib/celluloid.rb

@@ -6,16 +6,14 @@ require 'set'
 module Celluloid
   extend self # expose all instance methods as singleton methods
 
-  # How long actors have to terminate
-  SHUTDOWN_TIMEOUT = 10
-
   # Warning message added to Celluloid objects accessed outside their actors
   BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
 
   class << self
-    attr_accessor :internal_pool # Internal thread pool
-    attr_accessor :logger        # Thread-safe logger class
-    attr_accessor :task_class    # Default task type to use
+    attr_accessor :internal_pool    # Internal thread pool
+    attr_accessor :logger           # Thread-safe logger class
+    attr_accessor :task_class       # Default task type to use
+    attr_accessor :shutdown_timeout # How long actors have to terminate
 
     def included(klass)
       klass.send :extend,  ClassMethods
@@ -50,9 +48,26 @@ module Celluloid
       Logger.exception_handler(&block)
     end
 
+    def suspend(status, waiter)
+      task = Thread.current[:celluloid_task]
+      if task && !Celluloid.exclusive?
+        waiter.before_suspend(task) if waiter.respond_to?(:before_suspend)
+        Task.suspend(status)
+      else
+        waiter.wait
+      end
+    end
+
+    # Launch default services
+    # FIXME: We should set up the supervision hierarchy here
+    def boot
+      Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+      Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+    end
+
     # Shut down all running actors
     def shutdown
-      Timeout.timeout(SHUTDOWN_TIMEOUT) do
+      Timeout.timeout(shutdown_timeout) do
         actors = Actor.all
         Logger.debug "Terminating #{actors.size} actors..." if actors.size > 0
 
@@ -77,7 +92,7 @@ module Celluloid
         Logger.debug "Shutdown completed cleanly"
       end
     rescue Timeout::Error => ex
-      Logger.error("Couldn't cleanly terminate all actors in #{SHUTDOWN_TIMEOUT} seconds!")
+      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
     end
   end
 
@@ -204,6 +219,12 @@ module Celluloid
       end
     end
 
+    # 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
+    end
+
     # Configuration options for Actor#new
     def actor_options
       {
@@ -457,4 +478,8 @@ require 'celluloid/notifications'
 require 'celluloid/logging'
 
 require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
-require 'celluloid/boot'
+
+# Configure default systemwide settings
+Celluloid.task_class = Celluloid::TaskFiber
+Celluloid.logger     = Logger.new(STDERR)
+Celluloid.shutdown_timeout = 10

data/lib/celluloid/actor.rb

@@ -66,19 +66,7 @@ module Celluloid
           raise DeadActorError, "attempted to call a dead actor"
         end
 
-        if Thread.current[:celluloid_task] && !Celluloid.exclusive?
-          Task.suspend(:callwait).value
-        else
-          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[:celluloid_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
@@ -168,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
@@ -308,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)
-      task = Thread.current[:celluloid_task]
-      if task && !Celluloid.exclusive?
-        @timers.after(interval) { task.resume }
-        Task.suspend :sleeping
-      else
-        Kernel.sleep(interval)
-      end
+      sleeper = Sleeper.new(@timers, interval)
+      Celluloid.suspend(:sleeping, sleeper)
     end
 
     # Handle standard low-priority messages
@@ -390,7 +388,7 @@ module Celluloid
       end
 
       finalizer = @subject.class.finalizer
-      if finalizer && @subject.respond_to?(finalizer)
+      if finalizer && @subject.respond_to?(finalizer, true)
         task(:finalizer, :finalize) { @subject.__send__(finalizer) }
       end
     rescue => ex
@@ -415,7 +413,7 @@ 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.to_sym))
+      if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
         exclusive { block.call }
       else
         @task_class.new(task_type, &block).resume

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

@@ -11,34 +11,37 @@ module Celluloid
       obj.public_send(@method, *@arguments, &@block)
     rescue NoMethodError => ex
       # Abort if the caller made a mistake
-      detect_missing_method(ex)
+      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
-      detect_argument_error(ex)
-
-      # Otherwise something blew up. Crash this actor
-      raise
-    end
-
-  private
+      begin
+        arity = obj.method(@method).arity
+      rescue NameError
+        # In theory this shouldn't happen, but just in case
+        raise AbortError.new(ex)
+      end
 
-    # Detect NoMethodErrors made by the caller and abort
-    def detect_missing_method(ex)
-      ex.backtrace.each do |frame|
-        break if frame["celluloid/lib/celluloid/calls.rb"] || frame["`public_send'"]
-        return unless frame["`method_missing'"]
+      if arity >= 0
+        raise AbortError.new(ex) if @arguments.size != arity
+      elsif arity < -1
+        mandatory_args = -arity - 1
+        raise AbortError.new(ex) if arguments.size < mandatory_args
       end
 
-      raise AbortError.new(ex)
+      # Otherwise something blew up. Crash this actor
+      raise
     end
 
-    # Detect ArgumentErrors made by the caller and abort
-    def detect_argument_error(ex)
-      if ex.backtrace[0]["`#{@method}'"] && ex.backtrace[1]["`public_send'"]
-        raise AbortError.new(ex)
+    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

data/lib/celluloid/condition.rb

@@ -7,7 +7,7 @@ module Celluloid
 
     def initialize
       @mutex = Mutex.new
-      @owner = Actor.current
+      @owner = Thread.current[:celluloid_actor]
       @tasks = []
     end
 
@@ -16,7 +16,9 @@ module Celluloid
       raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
       @mutex.synchronize do
-        raise ConditionError, "can't wait unless owner" unless Actor.current == @owner
+        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
 
@@ -27,7 +29,9 @@ module Celluloid
 
     # Send a signal to the first task waiting on this condition
     def signal(value = nil)
-       @mutex.synchronize do
+      @mutex.synchronize do
+        raise ConditionError, "no owner for this condition" unless @owner
+
         if task = @tasks.shift
           @owner.mailbox << SignalConditionRequest.new(task, value)
         else
@@ -39,6 +43,8 @@ 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.clear
       end

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|processor)\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
+
+

data/lib/celluloid/future.rb

@@ -77,7 +77,7 @@ module Celluloid
       if result
         result.value
       else
-        raise "Timed out"
+        raise TimeoutError, "Timed out"
       end
     end
     alias_method :call, :value

data/lib/celluloid/logger.rb

@@ -53,7 +53,11 @@ module Celluloid
     # Format an exception message
     def format_exception(exception)
       str = "#{exception.class}: #{exception.to_s}\n\t"
-      str << exception.backtrace.join("\n\t")
+      if exception.backtrace
+        str << exception.backtrace.join("\n\t")
+      else
+        str << "EMPTY BACKTRACE\n\t"
+      end
     end
   end
 end

data/lib/celluloid/pool_manager.rb

@@ -113,7 +113,7 @@ module Celluloid
       signal :respawn_complete
     end
 
-    def respond_to?(method)
+    def respond_to?(method, include_private = false)
       super || @worker_class.instance_methods.include?(method.to_sym)
     end
 

data/lib/celluloid/stack_dump.rb

@@ -55,32 +55,40 @@ module Celluloid
 
     def dump(output = STDERR)
       @actors.each do |actor|
-        output << "Celluloid::Actor 0x#{actor.subject_id.to_s(16)}: #{actor.subject_class}"
-        output << " [#{actor.name}]" if actor.name
-        output << "\n"
+        string = ""
+        string << "Celluloid::Actor 0x#{actor.subject_id.to_s(16)}: #{actor.subject_class}"
+        string << " [#{actor.name}]" if actor.name
+        string << "\n"
 
         if actor.status == :idle
-          output << "State: Idle (waiting for messages)\n"
+          string << "State: Idle (waiting for messages)\n"
         else
-          output << "State: Running (executing tasks)\n"
-          output << "Tasks:\n"
+          string << "State: Running (executing tasks)\n"
+          string << "Tasks:\n"
 
           actor.tasks.each_with_index do |task, i|
-            output << "  #{i+1}) #{task.task_class}: #{task.status}\n"
+            string << "  #{i+1}) #{task.task_class}: #{task.status}\n"
           end
         end
 
-        display_backtrace actor.backtrace, output
+        display_backtrace actor.backtrace, string
+        output.print string
       end
 
       @threads.each do |thread|
-        output << "Thread 0x#{thread.thread_id.to_s(16)}:\n"
-        display_backtrace thread.backtrace, output
+        string = ""
+        string << "Thread 0x#{thread.thread_id.to_s(16)}:\n"
+        display_backtrace thread.backtrace, string
+        output.print string
       end
     end
 
     def display_backtrace(backtrace, output)
-      output << "\t" << backtrace.join("\n\t") << "\n\n"
+      if backtrace
+        output << "\t" << backtrace.join("\n\t") << "\n\n"
+      else
+        output << "EMPTY BACKTRACE\n\n"
+      end
     end
   end
 end

data/lib/celluloid/supervision_group.rb

@@ -60,7 +60,7 @@ module Celluloid
       @members = []
       @registry = registry || Registry.root
 
-      yield self if block_given?
+      yield current_actor if block_given?
     end
 
     def supervise(klass, *args, &block)

data/lib/celluloid/tasks.rb

@@ -25,6 +25,34 @@ module Celluloid
       @status = :new
     end
   end
+  
+  class TaskSet
+    include Enumerable
+  
+    def initialize
+      @tasks = Set.new
+    end
+  
+    def <<(task)
+      @tasks += [task]
+    end
+  
+    def delete(task)
+      @tasks -= [task]
+    end
+  
+    def each(&blk)
+      @tasks.each &blk
+    end
+  
+    def first
+      @tasks.first
+    end
+    
+    def empty?
+      @tasks.empty?
+    end
+  end
 end
 
 require 'celluloid/tasks/task_fiber'

data/lib/celluloid/tasks/task_thread.rb

@@ -8,6 +8,7 @@ module Celluloid
       super
 
       @resume_queue = Queue.new
+      @exception_queue = Queue.new
       @yield_mutex  = Mutex.new
       @yield_cond   = ConditionVariable.new
 
@@ -19,8 +20,8 @@ module Celluloid
 
       @thread = Celluloid.internal_pool.get do
         begin
-          ex = @resume_queue.pop.is_a?(Task::TerminatedError)
-          raise ex if ex
+          ex = @resume_queue.pop
+          raise ex if ex.is_a?(Task::TerminatedError)
 
           @status = :running
           Thread.current[:celluloid_actor]    = actor
@@ -32,6 +33,8 @@ module Celluloid
           yield
         rescue Task::TerminatedError
           # Task was explicitly terminated
+        rescue Exception => ex
+          @exception_queue << ex
         ensure
           @status = :dead
           actor.tasks.delete self
@@ -59,6 +62,9 @@ module Celluloid
       @yield_mutex.synchronize do
         @resume_queue.push(value)
         @yield_cond.wait(@yield_mutex)
+        while @exception_queue.size > 0
+          raise @exception_queue.pop
+        end
       end
 
       nil

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.13.0.pre'
+  VERSION = '0.13.0.pre2'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -130,6 +130,7 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.run do
       Celluloid.actor?
     end.should be_true
+    actor.should be_actor
   end
 
   it "inspects properly" do
@@ -253,7 +254,7 @@ shared_context "a Celluloid Actor" do |included_module|
         actor.crash_with_abort_raw 10
       end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
 
-      actor.greet rescue nil # Ensure our actor has died.
+      Celluloid::Actor.join(actor)
       actor.should_not be_alive
     end
   end
@@ -690,6 +691,22 @@ shared_context "a Celluloid Actor" do |included_module|
       sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
       actor.should_not be_fired
     end
+
+    it "allows delays from outside the actor" do
+      actor = @klass.new
+
+      interval = Celluloid::TIMER_QUANTUM * 10
+      started_at = Time.now
+      fired = false
+
+      timer = actor.after(interval) do
+        fired = true
+      end
+      fired.should be_false
+
+      sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
+      fired.should be_true
+    end
   end
 
   context :tasks do

data/spec/support/example_actor_class.rb

@@ -22,6 +22,10 @@ module ExampleActorClass
         "Hi, I'm #{@name}"
       end
 
+      def actor?
+        Celluloid.actor?
+      end
+
       def run(*args)
         yield(*args)
       end

data/spec/support/task_examples.rb

@@ -33,4 +33,13 @@ shared_context "a Celluloid Task" do |task_class|
     subject.should_not be_running
   end
 
+  it "raises exceptions outside" do
+    task = task_class.new(task_type) do
+      raise "failure"
+    end
+    expect do
+      task.resume
+    end.to raise_exception("failure")
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.13.0.pre
+  version: 0.13.0.pre2
   prerelease: 7
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2013-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
@@ -101,7 +101,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/celluloid/actor.rb
-- lib/celluloid/boot.rb
+- lib/celluloid/autostart.rb
 - lib/celluloid/calls.rb
 - lib/celluloid/condition.rb
 - lib/celluloid/core_ext.rb

data/lib/celluloid/boot.rb

@@ -1,23 +0,0 @@
-# Things to run after Celluloid is fully loaded
-
-# Configure default systemwide settings
-Celluloid.task_class = Celluloid::TaskFiber
-Celluloid.logger     = Logger.new(STDERR)
-
-# Launch default services
-# FIXME: We should set up the supervision hierarchy here
-Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
-Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
-
-# 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