celluloid 0.15.2 → 0.16.0.pre2

data/lib/celluloid/proxies/cell_proxy.rb

@@ -0,0 +1,68 @@
+module Celluloid
+  # A proxy object returned from Celluloid::Actor.new/new_link which converts
+  # the normal Ruby method protocol into an inter-actor message protocol
+  class CellProxy < SyncProxy
+    # Used for reflecting on proxy objects themselves
+    def __class__; CellProxy; end
+
+    def initialize(actor_proxy, mailbox, klass)
+      super(mailbox, klass)
+      @actor_proxy  = actor_proxy
+      @sync_proxy   = SyncProxy.new(mailbox, klass)
+      @async_proxy  = AsyncProxy.new(mailbox, klass)
+      @future_proxy = FutureProxy.new(mailbox, klass)
+    end
+
+    def _send_(meth, *args, &block)
+      method_missing :__send__, meth, *args, &block
+    end
+
+    def inspect
+      method_missing :inspect
+    rescue DeadActorError
+      "#<Celluloid::CellProxy(#{@klass}) dead>"
+    end
+
+    def method(name)
+      Method.new(self, name)
+    end
+
+    alias_method :sync, :method_missing
+
+    # Obtain an async proxy or explicitly invoke a named async method
+    def async(method_name = nil, *args, &block)
+      if method_name
+        @async_proxy.method_missing method_name, *args, &block
+      else
+        @async_proxy
+      end
+    end
+
+    # Obtain a future proxy or explicitly invoke a named future method
+    def future(method_name = nil, *args, &block)
+      if method_name
+        @future_proxy.method_missing method_name, *args, &block
+      else
+        @future_proxy
+      end
+    end
+
+    def alive?
+      @actor_proxy.alive?
+    end
+
+    def thread
+      @actor_proxy.thread
+    end
+
+    # Terminate the associated actor
+    def terminate
+      @actor_proxy.terminate
+    end
+
+    # Terminate the associated actor asynchronously
+    def terminate!
+      @actor_proxy.terminate!
+    end
+  end
+end

data/lib/celluloid/proxies/sync_proxy.rb

@@ -15,7 +15,7 @@ module Celluloid
     end
 
     def respond_to?(meth, include_private = false)
-      __class__.instance_methods.include?(meth) || super
+      __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
     end
 
     def method_missing(meth, *args, &block)

data/lib/celluloid/receivers.rb

@@ -1,4 +1,5 @@
 require 'set'
+
 require 'timers'
 
 module Celluloid
@@ -6,7 +7,7 @@ module Celluloid
   class Receivers
     def initialize
       @receivers = Set.new
-      @timers = Timers.new
+      @timers = Timers::Group.new
     end
 
     # Receive an asynchronous message
@@ -46,6 +47,7 @@ module Celluloid
       @receivers.delete receiver
       @timers.cancel receiver.timer if receiver.timer
       receiver.resume message
+      message
     end
   end
 

data/lib/celluloid/registry.rb

@@ -3,10 +3,6 @@ require 'thread'
 module Celluloid
   # The Registry allows us to refer to specific actors by human-meaningful names
   class Registry
-    class << self
-      attr_reader :root
-    end
-
     def initialize
       @registry = {}
       @registry_lock = Mutex.new
@@ -15,7 +11,7 @@ module Celluloid
     # Register an Actor
     def []=(name, actor)
       actor_singleton = class << actor; self; end
-      unless actor_singleton.ancestors.include? ActorProxy
+      unless actor_singleton.ancestors.include? AbstractProxy
         raise TypeError, "not an actor"
       end
 
@@ -57,8 +53,5 @@ module Celluloid
       end
       hash
     end
-
-    # Create the default registry
-    @root = new
   end
 end

data/lib/celluloid/stack_dump.rb

@@ -16,17 +16,21 @@ module Celluloid
 
     class ActorState
       include DisplayBacktrace
-
-      attr_accessor :subject_id, :subject_class, :name
+      attr_accessor :name, :id, :cell
       attr_accessor :status, :tasks
       attr_accessor :backtrace
 
       def dump
         string = ""
-        string << "Celluloid::Actor 0x#{subject_id.to_s(16)}: #{subject_class}"
+        string << "Celluloid::Actor 0x#{id.to_s(16)}"
         string << " [#{name}]" if name
         string << "\n"
 
+        if cell
+          string << cell.dump
+          string << "\n"
+        end
+
         if status == :idle
           string << "State: Idle (waiting for messages)\n"
           display_backtrace backtrace, string
@@ -46,12 +50,18 @@ module Celluloid
       end
     end
 
-    class ThreadState < Struct.new(:thread_id, :backtrace)
+    class CellState < Struct.new(:subject_id, :subject_class)
+      def dump
+        "Celluloid::Cell 0x#{subject_id.to_s(16)}: #{subject_class}"
+      end
+    end
+
+    class ThreadState < Struct.new(:thread_id, :backtrace, :role)
       include DisplayBacktrace
 
       def dump
         string = ""
-        string << "Thread 0x#{thread_id.to_s(16)}:\n"
+        string << "Thread 0x#{thread_id.to_s(16)} (#{role}):\n"
         display_backtrace backtrace, string
         string
       end
@@ -59,7 +69,9 @@ module Celluloid
 
     attr_accessor :actors, :threads
 
-    def initialize
+    def initialize(internal_pool)
+      @internal_pool = internal_pool
+
       @actors  = []
       @threads = []
 
@@ -67,7 +79,7 @@ module Celluloid
     end
 
     def snapshot
-      Celluloid.internal_pool.each do |thread|
+      @internal_pool.each do |thread|
         if thread.role == :actor
           @actors << snapshot_actor(thread.actor) if thread.actor
         else
@@ -78,8 +90,12 @@ module Celluloid
 
     def snapshot_actor(actor)
       state = ActorState.new
-      state.subject_id = actor.subject.object_id
-      state.subject_class = actor.subject.class
+      state.id = actor.object_id
+
+      # TODO: delegate to the behavior
+      if actor.behavior.is_a?(Cell)
+        state.cell = snapshot_cell(actor.behavior)
+      end
 
       tasks = actor.tasks
       if tasks.empty?
@@ -93,11 +109,18 @@ module Celluloid
       state
     end
 
+    def snapshot_cell(behavior)
+      state = CellState.new
+      state.subject_id = behavior.subject.object_id
+      state.subject_class = behavior.subject.class
+      state
+    end
+
     def snapshot_thread(thread)
-      ThreadState.new(thread.object_id, thread.backtrace)
+      ThreadState.new(thread.object_id, thread.backtrace, thread.role)
     end
 
-    def dump(output = STDERR)
+    def print(output = STDERR)
       @actors.each do |actor|
         output.print actor.dump
       end

data/lib/celluloid/supervision_group.rb

@@ -5,6 +5,7 @@ module Celluloid
     trap_exit :restart_actor
 
     class << self
+
       # Actors or sub-applications to be supervised
       def blocks
         @blocks ||= []
@@ -55,10 +56,12 @@ module Celluloid
       end
     end
 
+    finalizer :finalize
+
     # Start the group
     def initialize(registry = nil)
       @members = []
-      @registry = registry || Registry.root
+      @registry = registry || Celluloid.actor_system.registry
 
       yield current_actor if block_given?
     end
@@ -81,18 +84,15 @@ module Celluloid
     def add(klass, options)
       member = Member.new(@registry, klass, options)
       @members << member
-      member
+      member.actor
     end
 
     def actors
       @members.map(&:actor)
     end
 
-    finalizer :finalize
-
-    # Terminate the group
-    def finalize
-      @members.reverse_each(&:terminate)
+    def [](actor_name)
+      @registry[actor_name]
     end
 
     # Restart a crashed actor
@@ -102,7 +102,12 @@ module Celluloid
       end
       raise "a group member went missing. This shouldn't be!" unless member
 
-      member.restart(reason)
+      if reason
+        member.restart
+      else
+        member.cleanup
+        @members.delete(member)
+      end
     end
 
     # A member of the group
@@ -137,21 +142,28 @@ module Celluloid
         @registry[@name] = @actor if @name
       end
 
-      def restart(reason)
+      def restart
         @actor = nil
-        @registry.delete(@name) if @name
-
-        # Ignore supervisors that shut down cleanly
-        return unless reason
+        cleanup
 
         start
       end
 
       def terminate
-        @registry.delete(@name) if @name
+        cleanup
         @actor.terminate if @actor
       rescue DeadActorError
       end
+
+      def cleanup
+        @registry.delete(@name) if @name
+      end
+    end
+
+    private
+
+    def finalize
+      @members.reverse_each(&:terminate) if @members
     end
   end
 end

data/lib/celluloid/tasks/task_fiber.rb

@@ -6,10 +6,12 @@ module Celluloid
 
     def create
       queue = Thread.current[:celluloid_queue]
+      actor_system = Thread.current[:celluloid_actor_system]
       @fiber = Fiber.new do
         # FIXME: cannot use the writer as specs run inside normal Threads
         Thread.current[:celluloid_role] = :actor
         Thread.current[:celluloid_queue] = queue
+        Thread.current[:celluloid_actor_system] = actor_system
         yield
       end
     end
@@ -33,5 +35,9 @@ module Celluloid
     rescue FiberError
       # If we're getting this the task should already be dead
     end
+
+    def backtrace
+      ["#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::TaskThread` if you need backtraces here."]
+    end
   end
 end

data/lib/celluloid/tasks/task_thread.rb

@@ -12,7 +12,8 @@ module Celluloid
     end
 
     def create
-      @thread = Celluloid::ThreadHandle.new(:task) do
+      # TODO: move this to ActorSystem#get_thread (ThreadHandle inside InternalPool)
+      @thread = ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
         begin
           ex = @resume_queue.pop
           raise ex if ex.is_a?(Task::TerminatedError)

data/lib/celluloid/tasks.rb

@@ -74,14 +74,9 @@ module Celluloid
       @status = status
 
       if $CELLULOID_DEBUG && @dangerous_suspend
-        warning = "Dangerously suspending task: "
-        warning << [
-          "type=#{@type.inspect}",
-          "meta=#{@meta.inspect}",
-          "status=#{@status.inspect}"
-        ].join(", ")
-
-        Logger.warn [warning, *caller[2..8]].join("\n\t")
+        Logger.with_backtrace(caller[2...8]) do |logger|
+          logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        end
       end
 
       value = signal
@@ -118,7 +113,9 @@ module Celluloid
       raise "Cannot terminate an exclusive task" if exclusive?
 
       if running?
-        Celluloid.logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        Logger.with_backtrace(backtrace) do |logger|
+          logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        end
         exception = Task::TerminatedError.new("task was terminated")
         exception.set_backtrace(caller)
         resume exception

data/lib/celluloid/thread_handle.rb

@@ -3,11 +3,11 @@ module Celluloid
   # accidentally do things to threads which have been returned to the pool,
   # such as, say, killing them
   class ThreadHandle
-    def initialize(role = nil)
+    def initialize(actor_system, role = nil)
       @mutex = Mutex.new
       @join  = ConditionVariable.new
 
-      @thread = Celluloid.internal_pool.get do
+      @thread = actor_system.get_thread do
         Thread.current.role = role
         begin
           yield

data/lib/celluloid.rb

@@ -3,25 +3,32 @@ require 'thread'
 require 'timeout'
 require 'set'
 
-if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
-  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
-end
-
 module Celluloid
-  VERSION = '0.15.2'
-  Error = Class.new StandardError
+  # Expose all instance methods as singleton methods
+  extend self
+
+  VERSION = '0.16.0.pre2'
 
-  extend self # expose all instance methods as singleton methods
+  # Linking times out after 5 seconds
+  LINKING_TIMEOUT = 5
 
   # 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_writer   :actor_system     # Default Actor System
     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 actor_system
+      if Thread.current.celluloid?
+        Thread.current[:celluloid_actor_system] or raise Error, "actor system not running"
+      else
+        Thread.current[:celluloid_actor_system] || @actor_system or raise Error, "Celluloid is not yet started; use Celluloid.boot"
+      end
+    end
+
     def included(klass)
       klass.send :extend,  ClassMethods
       klass.send :include, InstanceMethods
@@ -29,19 +36,29 @@ module Celluloid
       klass.send :extend, Properties
 
       klass.property :mailbox_class, :default => Celluloid::Mailbox
-      klass.property :proxy_class,   :default => Celluloid::ActorProxy
+      klass.property :proxy_class,   :default => Celluloid::CellProxy
       klass.property :task_class,    :default => Celluloid.task_class
       klass.property :mailbox_size
 
+      klass.property :exclusive_actor, :default => false
+      klass.property :exclusive_methods, :multi => true
       klass.property :execute_block_on_receiver,
         :default => [:after, :every, :receive],
         :multi   => true
 
       klass.property :finalizer
-      klass.property :exit_handler
+      klass.property :exit_handler_name
 
       klass.send(:define_singleton_method, :trap_exit) do |*args|
-        exit_handler(*args)
+        exit_handler_name(*args)
+      end
+
+      klass.send(:define_singleton_method, :exclusive) do |*args|
+        if args.any?
+          exclusive_methods(*exclusive_methods, *args)
+        else
+          exclusive_actor true
+        end
       end
     end
 
@@ -69,7 +86,7 @@ module Celluloid
 
     # Perform a stack dump of all actors to the given output object
     def stack_dump(output = STDERR)
-      Celluloid::StackDump.new.dump(output)
+      actor_system.stack_dump.print(output)
     end
     alias_method :dump, :stack_dump
 
@@ -106,18 +123,15 @@ module Celluloid
     end
 
     def init
-      self.internal_pool = InternalPool.new
+      @actor_system = ActorSystem.new
     end
 
-    # Launch default services
-    # FIXME: We should set up the supervision hierarchy here
     def start
-      Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
-      Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+      actor_system.start
     end
 
     def running?
-      internal_pool
+      actor_system && actor_system.running?
     end
 
     def register_shutdown
@@ -139,41 +153,7 @@ module Celluloid
 
     # Shut down all running actors
     def shutdown
-      actors = Actor.all
-
-      Timeout.timeout(shutdown_timeout) do
-        internal_pool.shutdown
-
-        Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
-
-        # Attempt to shut down the supervision tree, if available
-        Supervisor.root.terminate if Supervisor.root
-
-        # Actors cannot self-terminate, you must do it for them
-        actors.each do |actor|
-          begin
-            actor.terminate!
-          rescue DeadActorError
-          end
-        end
-
-        actors.each do |actor|
-          begin
-            Actor.join(actor)
-          rescue DeadActorError
-          end
-        end
-      end
-    rescue Timeout::Error
-      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
-      actors.each do |actor|
-        begin
-          Actor.kill(actor)
-        rescue DeadActorError, MailboxDead
-        end
-      end
-    ensure
-      internal_pool.kill
+      actor_system.shutdown
     end
 
     def version
@@ -185,7 +165,7 @@ module Celluloid
   module ClassMethods
     # Create a new actor
     def new(*args, &block)
-      proxy = Actor.new(allocate, actor_options).proxy
+      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       proxy._send_(:initialize, *args, &block)
       proxy
     end
@@ -195,7 +175,7 @@ module Celluloid
     def new_link(*args, &block)
       raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
 
-      proxy = Actor.new(allocate, actor_options).proxy
+      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       Actor.link(proxy)
       proxy._send_(:initialize, *args, &block)
       proxy
@@ -233,26 +213,28 @@ module Celluloid
       Actor.join(new(*args, &block))
     end
 
-    # Mark methods as running exclusively
-    def exclusive(*methods)
-      if methods.empty?
-        @exclusive_methods = :all
-      elsif !defined?(@exclusive_methods) || @exclusive_methods != :all
-        @exclusive_methods ||= Set.new
-        @exclusive_methods.merge methods.map(&:to_sym)
-      end
+    def actor_system
+      Celluloid.actor_system
     end
 
     # Configuration options for Actor#new
     def actor_options
       {
+        :actor_system      => actor_system,
         :mailbox_class     => mailbox_class,
         :mailbox_size      => mailbox_size,
-        :proxy_class       => proxy_class,
         :task_class        => task_class,
-        :exit_handler      => exit_handler,
-        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil,
-        :receiver_block_executions => execute_block_on_receiver
+        :exclusive         => exclusive_actor,
+      }
+    end
+
+    def behavior_options
+      {
+        :proxy_class               => proxy_class,
+        :exclusive_methods         => exclusive_methods,
+        :exit_handler_name         => exit_handler_name,
+        :finalizer                 => finalizer,
+        :receiver_block_executions => execute_block_on_receiver,
       }
     end
 
@@ -291,9 +273,10 @@ module Celluloid
     end
 
     # Obtain the name of the current actor
-    def name
-      Actor.name
+    def registered_name
+      Actor.registered_name
     end
+    alias_method :name, :registered_name
 
     def inspect
       return "..." if Celluloid.detect_recursion
@@ -303,7 +286,7 @@ module Celluloid
       if leaked?
         str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
       else
-        str << "Celluloid::ActorProxy"
+        str << "Celluloid::CellProxy"
       end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
@@ -335,7 +318,7 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:celluloid_actor].proxy.terminate!
+    Thread.current[:celluloid_actor].behavior_proxy.terminate!
   end
 
   # Send a signal with the given name to all waiting methods
@@ -458,15 +441,21 @@ module Celluloid
 
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].proxy.async meth, *args, &block
+    Thread.current[:celluloid_actor].behavior_proxy.async meth, *args, &block
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].proxy.future meth, *args, &block
+    Thread.current[:celluloid_actor].behavior_proxy.future meth, *args, &block
   end
 end
 
+if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
+  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
+end
+
+require 'celluloid/exceptions'
+
 require 'celluloid/calls'
 require 'celluloid/call_chain'
 require 'celluloid/condition'
@@ -482,6 +471,7 @@ require 'celluloid/mailbox'
 require 'celluloid/evented_mailbox'
 require 'celluloid/method'
 require 'celluloid/properties'
+require 'celluloid/handlers'
 require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
@@ -495,13 +485,16 @@ require 'celluloid/uuid'
 
 require 'celluloid/proxies/abstract_proxy'
 require 'celluloid/proxies/sync_proxy'
+require 'celluloid/proxies/cell_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/cell'
 require 'celluloid/future'
+require 'celluloid/actor_system'
 require 'celluloid/pool_manager'
 require 'celluloid/supervision_group'
 require 'celluloid/supervisor'
@@ -510,6 +503,8 @@ require 'celluloid/logging'
 
 require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
 
+$CELLULOID_MONITORING = false
+
 # Configure default systemwide settings
 Celluloid.task_class = Celluloid::TaskFiber
 Celluloid.logger     = Logger.new(STDERR)