celluloid 0.16.0 → 0.17.0

data/lib/celluloid/actor.rb

@@ -1,5 +1,5 @@
 
-require 'timers'
+require "timers"
 
 module Celluloid
   # Actors are Celluloid's concurrency primitive. They're implemented as
@@ -12,37 +12,37 @@ module Celluloid
     class << self
       extend Forwardable
 
-      def_delegators "Celluloid.actor_system", :[], :[]=, :delete, :registered, :clear_registry
+      def_delegators :"Celluloid.actor_system", :[], :[]=, :delete, :registered, :clear_registry
 
       # Obtain the current actor
       def current
         actor = Thread.current[:celluloid_actor]
-        raise NotActorError, "not in actor scope" unless actor
+        fail NotActorError, "not in actor scope" unless actor
         actor.behavior_proxy
       end
 
       # Obtain the name of the current actor
       def registered_name
         actor = Thread.current[:celluloid_actor]
-        raise NotActorError, "not in actor scope" unless actor
+        fail NotActorError, "not in actor scope" unless actor
         actor.name
       end
 
       # Invoke a method on the given actor via its mailbox
       def call(mailbox, meth, *args, &block)
-        proxy = SyncProxy.new(mailbox, "UnknownClass")
+        proxy = Proxy::Sync.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)
-        proxy = AsyncProxy.new(mailbox, "UnknownClass")
+        proxy = Proxy::Async.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)
-        proxy = FutureProxy.new(mailbox, "UnknownClass")
+        proxy = Proxy::Future.new(mailbox, "UnknownClass")
         proxy.method_missing(meth, *args, &block)
       end
 
@@ -53,13 +53,13 @@ module Celluloid
 
       # Watch for exit events from another actor
       def monitor(actor)
-        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
         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?
+        fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
         Thread.current[:celluloid_actor].linking_request(actor, :unlink)
       end
 
@@ -85,10 +85,12 @@ module Celluloid
         monitoring?(actor) && Thread.current[:celluloid_actor].links.include?(actor)
       end
 
-      # Forcibly kill a given actor
-      def kill(actor)
-        actor.thread.kill
-        actor.mailbox.shutdown if actor.mailbox.alive?
+      unless RUBY_PLATFORM == "java" || RUBY_ENGINE == "rbx"
+        # Forcibly kill a given actor
+        def kill(actor)
+          actor.thread.kill
+          actor.mailbox.shutdown if actor.mailbox.alive?
+        end
       end
 
       # Wait for an actor to terminate
@@ -109,12 +111,12 @@ module Celluloid
       @exit_handler = method(:default_exit_handler)
       @exclusive    = options.fetch(:exclusive, false)
 
-      @tasks     = TaskSet.new
-      @links     = Links.new
-      @signals   = Signals.new
       @timers    = Timers::Group.new
-      @receivers = Receivers.new(@timers)
-      @handlers  = Handlers.new
+      @tasks     = Internals::TaskSet.new
+      @links     = Internals::Links.new
+      @handlers  = Internals::Handlers.new
+      @receivers = Internals::Receivers.new(@timers)
+      @signals   = Internals::Signals.new
       @running   = false
       @name      = nil
 
@@ -125,12 +127,12 @@ module Celluloid
 
     def start
       @running = true
-      @thread = ThreadHandle.new(@actor_system, :actor) do
+      @thread = Internals::ThreadHandle.new(@actor_system, :actor) do
         setup_thread
         run
       end
 
-      @proxy = ActorProxy.new(@thread, @mailbox)
+      @proxy = Proxy::Actor.new(@thread, @mailbox)
       Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
     end
 
@@ -148,8 +150,8 @@ module Celluloid
       while @running
         begin
           @timers.wait do |interval|
-            interval = 0 if interval and interval < 0
-            
+            interval = 0 if interval && interval < 0
+
             if message = @mailbox.check(interval)
               handle_message(message)
 
@@ -158,6 +160,9 @@ module Celluloid
           end
         rescue MailboxShutdown
           @running = false
+        rescue MailboxDead
+          # TODO: not tests (but fails occasionally in tests)
+          @running = false
         end
       end
 
@@ -191,19 +196,16 @@ module Celluloid
 
           if message.instance_of? LinkingResponse
             Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
-
-            # We're done!
             system_events.each { |ev| @mailbox << ev }
-
             return
           elsif message.is_a? SystemEvent
             # Queue up pending system events to be processed after we've successfully linked
             system_events << message
-          else raise "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
+          else fail "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
           end
         end
 
-        raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
+        fail TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
       end
     end
 
@@ -223,9 +225,9 @@ module Celluloid
 
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
-      loop do
+      while true
         message = @receivers.receive(timeout, &block)
-        break message unless message.is_a?(SystemEvent)
+        return message unless message.is_a?(SystemEvent)
 
         handle_system_event(message)
       end
@@ -279,7 +281,7 @@ module Celluloid
     def handle_message(message)
       unless @handlers.handle_message(message)
         unless @receivers.handle_message(message)
-          Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+          Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
         end
       end
       message
@@ -299,7 +301,7 @@ module Celluloid
       elsif event.instance_of? SignalConditionRequest
         event.call
       else
-        Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+        Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
       end
     end
 
@@ -311,16 +313,16 @@ module Celluloid
     end
 
     def default_exit_handler(event)
-      raise event.reason if event.reason
+      fail event.reason if event.reason
     end
 
     # Handle any exceptions that occur within a running actor
     def handle_crash(exception)
       # TODO: add meta info
-      Logger.crash("Actor crashed!", exception)
+      Internals::Logger.crash("Actor crashed!", exception)
       shutdown ExitEvent.new(behavior_proxy, exception)
     rescue => ex
-      Logger.crash("ERROR HANDLER CRASHED!", ex)
+      Internals::Logger.crash("Actor#handle_crash CRASHED!", ex)
     end
 
     # Handle cleaning up this actor after it exits
@@ -337,26 +339,30 @@ module Celluloid
       Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
       @mailbox.shutdown
       @links.each do |actor|
-        if actor.mailbox.alive?
-          actor.mailbox << exit_event
-        end
+        actor.mailbox << exit_event if actor.mailbox.alive?
       end
 
-      tasks.to_a.each(&:terminate)
+      tasks.to_a.each do |task|
+        begin
+          task.terminate
+        rescue DeadTaskError
+          # TODO: not tested (failed on Travis)
+        end
+      end
     rescue => ex
       # TODO: metadata
-      Logger.crash("CLEANUP CRASHED!", ex)
+      Internals::Logger.crash("CLEANUP CRASHED!", ex)
     end
 
     # Run a method inside a task unless it's exclusive
     def task(task_type, meta = nil)
-      @task_class.new(task_type, meta) {
+      @task_class.new(task_type, meta) do
         if @exclusive
           Celluloid.exclusive { yield }
         else
           yield
         end
-      }.resume
+      end.resume
     end
   end
 end

data/lib/celluloid/actor_system.rb

@@ -1,19 +1,63 @@
 module Celluloid
+  extend Forwardable
+  def_delegators :actor_system, :[], :[]=
+
   class ActorSystem
     extend Forwardable
+    def_delegators :@registry, :[], :get, :[]=, :set, :delete
+
+    ROOT_SERVICES = [
+      {
+        as: :notifications_fanout,
+        type: Celluloid::Notifications::Fanout,
+      },
+      {
+        as: :incident_reporter,
+        type: Celluloid::IncidentReporter,
+        args: [STDERR],
+      },
+      {
+        as: :group_manager,
+        type: Celluloid::Group::Manager,
+        accessors: [:manager],
+      },
+      {
+        as: :public_services,
+        type: Celluloid::Supervision::Service::Public,
+        accessors: [:services],
+        supervise: [],
+      },
+    ]
+
+    attr_reader :registry, :group
+
+    module Error
+      class Uninitialized < StandardError; end
+    end
+
+    # the root of the supervisor tree is established at supervision/root
+
+    def root_services
+      @tree
+    end
+
+    def root_configuration
+      @root
+    end
 
     def initialize
-      @internal_pool = InternalPool.new
-      @registry      = Registry.new
+      @tree = nil
+      @group = Celluloid.group_class.new
+      @registry = Internals::Registry.new
+      @root = ROOT_SERVICES
     end
-    attr_reader :registry
 
     # Launch default services
-    # FIXME: We should set up the supervision hierarchy here
     def start
       within do
-        Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
-        Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+        @root = Supervision::Service::Root.define
+        @tree = root_configuration.deploy
+        # de root_services[:group_manager].manage! @group
       end
       true
     end
@@ -27,17 +71,19 @@ module Celluloid
     end
 
     def get_thread
-      @internal_pool.get do
+      @group.get do
         Thread.current[:celluloid_actor_system] = self
         yield
       end
     end
 
     def stack_dump
-      Celluloid::StackDump.new(@internal_pool)
+      Internals::Stack::Dump.new(@group)
     end
 
-    def_delegators "@registry", :[], :get, :[]=, :set, :delete
+    def stack_summary
+      Internals::Stack::Summary.new(@group)
+    end
 
     def registered
       @registry.names
@@ -49,22 +95,29 @@ module Celluloid
 
     def running
       actors = []
-      @internal_pool.each do |t|
+      @group.each do |t|
         next unless t.role == :actor
-        actors << t.actor.behavior_proxy if t.actor && t.actor.respond_to?(:behavior_proxy)
+        actor = t.actor
+
+        # NOTE - these are in separate statements, since on JRuby t.actor may
+        # become nil befor .behavior_proxy() is called
+        next unless actor
+        next unless actor.respond_to?(:behavior_proxy)
+        proxy = actor.behavior_proxy
+        actors << proxy
       end
       actors
     end
 
     def running?
-      @internal_pool.running?
+      @group.active?
     end
 
     # Shut down all running actors
     def shutdown
       actors = running
       Timeout.timeout(shutdown_timeout) do
-        Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
+        Internals::Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
 
         # Actors cannot self-terminate, you must do it for them
         actors.each do |actor|
@@ -80,24 +133,24 @@ module Celluloid
           rescue DeadActorError
           end
         end
-
-        @internal_pool.shutdown
       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
+      Internals::Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
+      unless RUBY_PLATFORM == "java" || RUBY_ENGINE == "rbx"
+        actors.each do |actor|
+          begin
+            Actor.kill(actor)
+          rescue DeadActorError, MailboxDead
+          end
         end
       end
     ensure
-      @internal_pool.kill
+      @group.shutdown
       clear_registry
     end
 
     def assert_inactive
-      @internal_pool.assert_inactive
+      @group.assert_inactive
     end
 
     def shutdown_timeout

data/lib/celluloid/autostart.rb

@@ -1,3 +1,3 @@
-require 'celluloid'
+require "celluloid"
 
 Celluloid.start

data/lib/celluloid/backported.rb

@@ -0,0 +1,2 @@
+$CELLULOID_BACKPORTED = true
+require "celluloid/autostart"

data/lib/celluloid/call/async.rb

@@ -0,0 +1,16 @@
+module Celluloid
+  class Call
+    # Asynchronous calls don't wait for a response
+    class Async < Call
+      def dispatch(obj)
+        Internals::CallChain.current_id = Celluloid.uuid
+        super(obj)
+      rescue AbortError => ex
+        # Swallow aborted async calls, as they indicate the sender made a mistake
+        Internals::Logger.debug("#{obj.class}: async call `#{@method}` aborted!\n#{Internals::Logger.format_exception(ex.cause)}")
+      ensure
+        Internals::CallChain.current_id = nil
+      end
+    end
+  end
+end

data/lib/celluloid/call/block.rb

@@ -0,0 +1,22 @@
+module Celluloid
+  class Call
+    class Block
+      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 << Internals::Response::Block.new(self, response)
+      end
+    end
+  end
+end