celluloid 0.14.1 → 0.15.0.pre

data/lib/celluloid/pool_manager.rb

@@ -27,7 +27,7 @@ module Celluloid
       terminators = (@idle + @busy).each do |actor|
         begin
           actor.future(:terminate)
-        rescue DeadActorError, MailboxError
+        rescue DeadActorError
         end
       end
 

data/lib/celluloid/properties.rb

@@ -0,0 +1,24 @@
+module Celluloid
+  # Properties define inheritable attributes of classes, somewhat similar to
+  # Rails cattr_*/mattr_* or class_attribute
+  module Properties
+    def property(name, opts = {})
+      default   = opts.fetch(:default, nil)
+      multi     = opts.fetch(:multi, false)
+      ivar_name = "@#{name}".to_sym
+
+      ancestors.first.send(:define_singleton_method, name) do |value = nil, *extra|
+        if value
+          value = value ? [value, *extra] : [] if multi
+          instance_variable_set(ivar_name, value)
+        elsif instance_variables.include?(ivar_name)
+          instance_variable_get(ivar_name)
+        elsif superclass.respond_to? name
+          superclass.send(name)
+        else
+          default
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/proxies/abstract_proxy.rb

@@ -1,6 +1,9 @@
 module Celluloid
   # Base class of all Celluloid proxies
   class AbstractProxy < BasicObject
+    # Used for reflecting on proxy objects themselves
+    def __class__; AbstractProxy; end
+
     # Needed for storing proxies in data structures
     needed = [:object_id, :__id__, :hash] - instance_methods
     if needed.any?

data/lib/celluloid/proxies/actor_proxy.rb

@@ -4,6 +4,9 @@ module Celluloid
   class ActorProxy < SyncProxy
     attr_reader :thread
 
+    # Used for reflecting on proxy objects themselves
+    def __class__; ActorProxy; end
+
     def initialize(actor)
       @thread = actor.thread
 
@@ -13,14 +16,6 @@ module Celluloid
       @future_proxy = FutureProxy.new(@mailbox, @klass)
     end
 
-    def class
-      method_missing :__send__, :class
-    end
-
-    def send(meth, *args, &block)
-      method_missing :send, meth, *args, &block
-    end
-
     def _send_(meth, *args, &block)
       method_missing :__send__, meth, *args, &block
     end
@@ -31,26 +26,6 @@ module Celluloid
       "#<Celluloid::ActorProxy(#{@klass}) dead>"
     end
 
-    def name
-      method_missing :name
-    end
-
-    def is_a?(klass)
-      method_missing :is_a?, klass
-    end
-
-    def kind_of?(klass)
-      method_missing :kind_of?, klass
-    end
-
-    def respond_to?(meth, include_private = false)
-      method_missing :respond_to?, meth, include_private
-    end
-
-    def methods(include_ancestors = true)
-      method_missing :methods, include_ancestors
-    end
-
     def method(name)
       Method.new(self, name)
     end
@@ -59,10 +34,6 @@ module Celluloid
       @mailbox.alive?
     end
 
-    def to_s
-      method_missing :to_s
-    end
-
     alias_method :sync, :method_missing
 
     # Obtain an async proxy or explicitly invoke a named async method

data/lib/celluloid/proxies/async_proxy.rb

@@ -3,6 +3,9 @@ module Celluloid
   class AsyncProxy < AbstractProxy
     attr_reader :mailbox
 
+    # Used for reflecting on proxy objects themselves
+    def __class__; AsyncProxy; end
+
     def initialize(mailbox, klass)
       @mailbox, @klass = mailbox, klass
     end
@@ -22,14 +25,7 @@ module Celluloid
         raise "Cannot use blocks with async yet"
       end
 
-      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
+      @mailbox << AsyncCall.new(meth, args, block)
     end
   end
 end

data/lib/celluloid/proxies/future_proxy.rb

@@ -3,6 +3,9 @@ module Celluloid
   class FutureProxy < AbstractProxy
     attr_reader :mailbox
 
+    # Used for reflecting on proxy objects themselves
+    def __class__; FutureProxy; end
+
     def initialize(mailbox, klass)
       @mailbox, @klass = mailbox, klass
     end
@@ -11,8 +14,11 @@ module Celluloid
       "#<Celluloid::FutureProxy(#{@klass})>"
     end
 
-    # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
+      unless @mailbox.alive?
+        raise DeadActorError, "attempted to call a dead actor"
+      end
+
       if block_given?
         # FIXME: nicer exception
         raise "Cannot use blocks with futures yet"
@@ -21,11 +27,7 @@ module Celluloid
       future = Future.new
       call = SyncCall.new(future, meth, args, block)
 
-      begin
-        @mailbox << call
-      rescue MailboxError
-        raise DeadActorError, "attempted to call a dead actor"
-      end
+      @mailbox << call
 
       future
     end

data/lib/celluloid/proxies/sync_proxy.rb

@@ -3,6 +3,9 @@ module Celluloid
   class SyncProxy < AbstractProxy
     attr_reader :mailbox
 
+    # Used for reflecting on proxy objects themselves
+    def __class__; SyncProxy; end
+
     def initialize(mailbox, klass)
       @mailbox, @klass = mailbox, klass
     end
@@ -11,20 +14,22 @@ module Celluloid
       "#<Celluloid::SyncProxy(#{@klass})>"
     end
 
+    def respond_to?(meth, include_private = false)
+      __class__.instance_methods.include?(meth) || super
+    end
+
     def method_missing(meth, *args, &block)
+      unless @mailbox.alive?
+        raise DeadActorError, "attempted to call a dead actor"
+      end
+
       if @mailbox == ::Thread.current[:celluloid_mailbox]
         args.unshift meth
         meth = :__send__
       end
 
       call = SyncCall.new(::Celluloid.mailbox, meth, args, block)
-
-      begin
-        @mailbox << call
-      rescue MailboxError
-        raise DeadActorError, "attempted to call a dead actor"
-      end
-
+      @mailbox << call
       call.value
     end
   end

data/lib/celluloid/rspec.rb

@@ -5,4 +5,6 @@ require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)
 module Celluloid
   # Timer accuracy enforced by the tests (50ms)
   TIMER_QUANTUM = 0.05
-end
+end
+
+$CELLULOID_DEBUG = true

data/lib/celluloid/signals.rb

@@ -1,51 +1,23 @@
 module Celluloid
   # Event signaling between methods of the same object
   class Signals
-    attr_reader :waiting
-
     def initialize
-      @waiting = {}
+      @conditions = {}
     end
 
     # Wait for the given signal and return the associated value
-    def wait(signal)
+    def wait(name)
       raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
-      tasks = @waiting[signal]
-      case tasks
-      when Array
-        tasks << Task.current
-      when NilClass
-        @waiting[signal] = Task.current
-      else
-        @waiting[signal] = [tasks, Task.current]
-      end
-
-      Task.suspend :sigwait
+      @conditions[name] ||= Condition.new
+      @conditions[name].wait
     end
 
     # Send a signal to all method calls waiting for the given name
-    # Returns true if any calls were signaled, or false otherwise
-    def send(name, value = nil)
-      tasks = @waiting.delete name
-
-      case tasks
-      when Array
-        tasks.each { |task| run_task task, value }
-        true if tasks.size > 0
-      when NilClass
-        false
-      else
-        run_task tasks, value
-        true
+    def broadcast(name, value = nil)
+      if condition = @conditions.delete(name)
+        condition.broadcast(value)
       end
     end
-
-    # Run the given task, reporting errors that occur
-    def run_task(task, value)
-      task.resume(value)
-    rescue => ex
-      Logger.crash("signaling error", ex)
-    end
   end
 end

data/lib/celluloid/stack_dump.rb

@@ -1,16 +1,60 @@
 module Celluloid
   class StackDump
+    module DisplayBacktrace
+      def display_backtrace(backtrace, output, indent = nil)
+        backtrace ||= ["EMPTY BACKTRACE"]
+        backtrace.each do |line|
+          output << indent if indent
+          output << "\t" << line << "\n"
+        end
+        output << "\n\n"
+      end
+    end
 
-    class TaskState < Struct.new(:task_class, :status, :backtrace)
+    class TaskState < Struct.new(:task_class, :type, :meta, :status, :backtrace)
     end
 
     class ActorState
+      include DisplayBacktrace
+
       attr_accessor :subject_id, :subject_class, :name
       attr_accessor :status, :tasks
       attr_accessor :backtrace
+
+      def dump
+        string = ""
+        string << "Celluloid::Actor 0x#{subject_id.to_s(16)}: #{subject_class}"
+        string << " [#{name}]" if name
+        string << "\n"
+
+        if status == :idle
+          string << "State: Idle (waiting for messages)\n"
+          display_backtrace backtrace, string
+        else
+          string << "State: Running (executing tasks)\n"
+          display_backtrace backtrace, string
+          string << "\tTasks:\n"
+
+          tasks.each_with_index do |task, i|
+            string << "\t  #{i+1}) #{task.task_class}[#{task.type}]: #{task.status}\n"
+            string << "\t      #{task.meta.inspect}\n"
+            display_backtrace task.backtrace, string, "\t"
+          end
+        end
+
+        string
+      end
     end
 
     class ThreadState < Struct.new(:thread_id, :backtrace)
+      include DisplayBacktrace
+
+      def dump
+        string = ""
+        string << "Thread 0x#{thread_id.to_s(16)}:\n"
+        display_backtrace backtrace, string
+        string
+      end
     end
 
     attr_accessor :actors, :threads
@@ -23,9 +67,8 @@ module Celluloid
     end
 
     def snapshot
-      Thread.list.each do |thread|
-        if thread.celluloid?
-          next unless thread.role == :actor
+      Celluloid.internal_pool.each do |thread|
+        if thread.role == :actor
           @actors << snapshot_actor(thread.actor) if thread.actor
         else
           @threads << snapshot_thread(thread)
@@ -43,7 +86,7 @@ module Celluloid
         state.status = :idle
       else
         state.status = :running
-        state.tasks = tasks.collect { |t| TaskState.new(t.class, t.status, t.backtrace) }
+        state.tasks = tasks.to_a.map { |t| TaskState.new(t.class, t.type, t.meta, t.status, t.backtrace) }
       end
 
       state.backtrace = actor.thread.backtrace if actor.thread
@@ -56,41 +99,11 @@ module Celluloid
 
     def dump(output = STDERR)
       @actors.each do |actor|
-        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
-          string << "State: Idle (waiting for messages)\n"
-          display_backtrace actor.backtrace, string
-        else
-          string << "State: Running (executing tasks)\n"
-          display_backtrace actor.backtrace, string
-          string << "Tasks:\n"
-
-          actor.tasks.each_with_index do |task, i|
-            string << "  #{i+1}) #{task.task_class}: #{task.status}\n"
-            display_backtrace task.backtrace, string
-          end
-        end
-
-        output.print string
+        output.print actor.dump
       end
 
       @threads.each do |thread|
-        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)
-      if backtrace
-        output << "\t" << backtrace.join("\n\t") << "\n\n"
-      else
-        output << "EMPTY BACKTRACE\n\n"
+        output.print thread.dump
       end
     end
   end

data/lib/celluloid/supervision_group.rb

@@ -11,8 +11,8 @@ module Celluloid
       end
 
       # Start this application (and watch it with a supervisor)
-      def run!
-        group = new do |_group|
+      def run!(registry = nil)
+        group = new(registry) do |_group|
           blocks.each do |block|
             block.call(_group)
           end
@@ -21,9 +21,9 @@ module Celluloid
       end
 
       # Run the application in the foreground with a simple watchdog
-      def run
+      def run(registry = nil)
         loop do
-          supervisor = run!
+          supervisor = run!(registry)
 
           # Take five, toplevel supervisor
           sleep 5 while supervisor.alive?
@@ -149,7 +149,7 @@ module Celluloid
 
       def terminate
         @actor.terminate if @actor
-      rescue DeadActorError, MailboxError
+      rescue DeadActorError
       end
     end
   end

data/lib/celluloid/task_set.rb

@@ -0,0 +1,49 @@
+require 'set'
+require 'forwardable'
+
+module Celluloid
+  if defined? JRUBY_VERSION
+    require 'jruby/synchronized'
+
+    class TaskSet
+      extend  Forwardable
+      include JRuby::Synchronized
+
+      def_delegators :@tasks, :<<, :delete, :first, :empty?, :to_a
+
+      def initialize
+        @tasks = Set.new
+      end
+    end
+  elsif defined? Rubinius
+    class TaskSet
+      def initialize
+        @tasks = Set.new
+      end
+
+      def <<(task)
+        Rubinius.synchronize(self) { @tasks << task }
+      end
+
+      def delete(task)
+        Rubinius.synchronize(self) { @tasks.delete task }
+      end
+
+      def first
+        Rubinius.synchronize(self) { @tasks.first }
+      end
+
+      def empty?
+        Rubinius.synchronize(self) { @tasks.empty? }
+      end
+
+      def to_a
+        Rubinius.synchronize(self) { @tasks.to_a }
+      end
+    end
+  else
+    # Assume we're on MRI, where we have the GIL. But what about IronRuby?
+    # Or MacRuby. Do people care? This will break Celluloid::StackDumps
+    TaskSet = Set
+  end
+end