celluloid 0.16.0 → 0.17.3

data/examples/timers.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/current"
+
+class TimerExample
+  include Celluloid
+  attr_reader :fired, :timer
+
+  def initialize
+    @fired = false
+    @timer = after(3) { puts "Timer fired!"; @fired = true }
+  end
+end
+
+#
+# Basic timer example
+#
+
+actor = TimerExample.new
+
+# The timer hasn't fired yet, so this should be false
+puts "Timer hasn't fired yet, so this should be false: #{actor.fired}"
+
+# Even if we wait a second, it still hasn't fired
+sleep 1
+puts "Timer still shouldn't have fired yet: #{actor.fired}"
+
+# Wait until after the timer should've fired
+sleep 2.1
+puts "Timer should've fired now: #{actor.fired}"
+
+#
+# Cancelling timers
+#
+
+actor = TimerExample.new
+
+# The timer hasn't fired yet, so this should be false
+puts "Timer hasn't fired yet, so this should be false: #{actor.fired}"
+
+# Cancel the timer, which should prevent it from firing
+actor.timer.cancel
+
+# Wait until after the timer should've fired
+sleep 3.1
+puts "Timer shouldn't have fired because we cancelled it: #{actor.fired}"
+
+class RepeatingTimerExample
+  include Celluloid
+
+  def initialize
+    @sheep = 0
+  end
+
+  def count_sheep
+    print "<#{self.class.name}> Counting sheep to go to sleep: "
+    @timer = every(0.1) do
+      @sheep += 1
+      print @sheep, " "
+    end
+  end
+
+  def stop_counting
+    @timer.cancel
+  end
+end
+
+sleepy_actor = RepeatingTimerExample.new
+sleepy_actor.count_sheep
+sleep 1
+sleepy_actor.stop_counting

data/lib/celluloid/actor/manager.rb

@@ -0,0 +1,7 @@
+module Celluloid
+  class Actor
+    class Manager
+      include Celluloid
+    end
+  end
+end

data/lib/celluloid/actor/system.rb

@@ -0,0 +1,163 @@
+module Celluloid
+  extend Forwardable
+  def_delegators :actor_system, :[], :[]=
+
+  class Actor
+    class System
+      extend Forwardable
+      def_delegators :@registry, :[], :get, :[]=, :set, :delete
+
+      ROOT_SERVICES = begin
+        root_services = [
+          {
+            as: :notifications_fanout,
+            type: Celluloid::Notifications::Fanout,
+          },
+          {
+            as: :incident_reporter,
+            type: Celluloid::IncidentReporter,
+            args: [STDERR],
+          },
+          {
+            as: :public_services,
+            type: Celluloid::Supervision::Service::Public,
+            accessors: [:services],
+            supervise: [],
+          },
+        ]
+        if $CELLULOID_MANAGED
+          root_services << {
+            as: :actor_manager,
+            type: Celluloid::Actor::Manager,
+            accessors: [:manager],
+          }
+        end
+        root_services
+      end
+
+      attr_reader :registry, :group
+
+      # the root of the supervisor tree is established at supervision/root
+
+      def root_services
+        @tree
+      end
+
+      def root_configuration
+        @root
+      end
+
+      def initialize
+        @tree = nil
+        @group = Celluloid.group_class.new
+        @registry = Internals::Registry.new
+        @root = ROOT_SERVICES
+      end
+
+      # Launch default services
+      def start
+        within do
+          @root = Supervision::Service::Root.define
+          @tree = root_configuration.deploy
+          # de root_services[:group_manager].manage! @group
+        end
+        true
+      end
+
+      def within
+        old = Thread.current[:celluloid_actor_system]
+        Thread.current[:celluloid_actor_system] = self
+        yield
+      ensure
+        Thread.current[:celluloid_actor_system] = old
+      end
+
+      def get_thread
+        @group.get do
+          Thread.current[:celluloid_actor_system] = self
+          yield
+        end
+      end
+
+      def stack_dump
+        Internals::Stack::Dump.new(@group)
+      end
+
+      def stack_summary
+        Internals::Stack::Summary.new(@group)
+      end
+
+      def registered
+        @registry.names
+      end
+
+      def clear_registry
+        @registry.clear
+      end
+
+      def running
+        actors = []
+        @group.each do |t|
+          next unless t.role == :actor
+          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?
+        @group.active?
+      end
+
+      # Shut down all running actors
+      def shutdown
+        actors = running
+        Timeout.timeout(shutdown_timeout) do
+          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|
+            begin
+              actor.terminate!
+            rescue DeadActorError
+            end
+          end
+
+          actors.each do |actor|
+            begin
+              Actor.join(actor)
+            rescue DeadActorError
+            end
+          end
+        end
+      rescue Timeout::Error
+        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
+        @group.shutdown
+        clear_registry
+      end
+
+      def assert_inactive
+        @group.assert_inactive
+      end
+
+      def shutdown_timeout
+        Celluloid.shutdown_timeout
+      end
+    end
+  end
+end

data/lib/celluloid/actor.rb

@@ -1,5 +1,4 @@
-
-require 'timers'
+require "timers"
 
 module Celluloid
   # Actors are Celluloid's concurrency primitive. They're implemented as
@@ -12,37 +11,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 +52,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 +84,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 +110,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,13 +126,14 @@ 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(@mailbox, @thread)
       Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
+      Celluloid::Actor::Manager.actor_created(self) if $CELLULOID_MANAGED
     end
 
     def behavior_proxy
@@ -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,13 +160,16 @@ module Celluloid
           end
         rescue MailboxShutdown
           @running = false
+        rescue MailboxDead
+          # TODO: not tests (but fails occasionally in tests)
+          @running = false
         end
       end
 
       shutdown
-    rescue Exception => ex
+    rescue ::Exception => ex
       handle_crash(ex)
-      raise unless ex.is_a? StandardError
+      raise unless ex.is_a?(StandardError) || ex.is_a?(Celluloid::Interruption)
     end
 
     # Terminate this actor
@@ -185,25 +190,22 @@ module Celluloid
               msg.actor.mailbox.address == receiver.mailbox.address &&
               msg.type == type
             end
-          rescue TimeoutError
+          rescue TaskTimeout
             next # IO reactor did something, no message in queue yet.
           end
 
           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 TaskTimeout, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
       end
     end
 
@@ -216,16 +218,17 @@ module Celluloid
     def wait(name)
       @signals.wait name
     end
-
+    
+    # Register a new handler for a given pattern
     def handle(*patterns, &block)
       @handlers.handle(*patterns, &block)
     end
 
     # 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
@@ -245,7 +248,7 @@ module Celluloid
       bt = caller
       task = Task.current
       timer = @timers.after(duration) do
-        exception = Task::TimeoutError.new("execution expired")
+        exception = TaskTimeout.new("execution expired")
         exception.set_backtrace bt
         task.resume exception
       end
@@ -279,48 +282,23 @@ 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
     end
 
-    # Handle high-priority system event messages
-    def handle_system_event(event)
-      if event.instance_of? ExitEvent
-        handle_exit_event(event)
-      elsif event.instance_of? LinkingRequest
-        event.process(links)
-      elsif event.instance_of? NamingRequest
-        @name = event.name
-        Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
-      elsif event.instance_of? TerminationRequest
-        terminate
-      elsif event.instance_of? SignalConditionRequest
-        event.call
-      else
-        Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
-      end
-    end
-
-    # Handle exit events received by this actor
-    def handle_exit_event(event)
-      @links.delete event.actor
-
-      @exit_handler.call(event)
-    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 +315,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/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

data/lib/celluloid/call/sync.rb

@@ -0,0 +1,70 @@
+module Celluloid
+  class Call
+    # Synchronous calls wait for a response
+    class Sync < Call
+      attr_reader :sender, :task, :chain_id
+
+      def initialize(sender, method, arguments = [], block = nil, task = Thread.current[:celluloid_task], chain_id = Internals::CallChain.current_id)
+        super(method, arguments, block)
+        @sender   = sender
+        @task     = task
+        @chain_id = chain_id || Celluloid.uuid
+      end
+
+      def dispatch(obj)
+        Internals::CallChain.current_id = @chain_id
+        result = super(obj)
+        respond Internals::Response::Success.new(self, result)
+      rescue ::Exception => ex
+        # Exceptions that occur during synchronous calls are reraised in the
+        # context of the sender
+        respond Internals::Response::Error.new(self, ex)
+
+        # Aborting indicates a protocol error on the part of the sender
+        # It should crash the sender, 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
+        Internals::CallChain.current_id = nil
+      end
+
+      def cleanup
+        exception = DeadActorError.new("attempted to call a dead actor: #{self.method}")
+        respond Internals::Response::Error.new(self, exception)
+      end
+
+      def respond(message)
+        @sender << message
+      end
+
+      def response
+        Celluloid.suspend(:callwait, self)
+      end
+
+      def value
+        response.value
+      end
+
+      def wait
+        while true
+          message = Celluloid.mailbox.receive do |msg|
+            msg.respond_to?(:call) && msg.call == self
+          end
+
+          if message.is_a?(SystemEvent)
+            Thread.current[:celluloid_actor].handle_system_event(message)
+          else
+            # FIXME: add check for receiver block execution
+            if message.respond_to?(:value)
+              # FIXME: disable block execution if on :sender and (exclusive or outside of task)
+              # probably now in Call
+              return message
+            else
+              message.dispatch
+            end
+          end
+        end
+      end
+    end
+  end
+end