celluloid 0.16.0 → 0.17.3

data/lib/celluloid/system_events.rb

@@ -1,14 +1,54 @@
 module Celluloid
+  class Actor
+    # Handle high-priority system event messages
+    def handle_system_event(event)
+      if handler = SystemEvent.handle(event.class)
+        send(handler, event)
+      else
+        Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+      end
+    end
+  end
   # High-priority internal system events
-  class SystemEvent; end
+  class SystemEvent
+    class << self
+      @@system_events = {}
+      def handle(type)
+        @@system_events[type]
+      end
+
+      def handler(&block)
+        fail ArgumentError, "SystemEvent handlers must be defined with a block." unless block
+        method = begin
+          handler = name
+                    .split("::").last
+                    .gsub(/([A-Z]+)([A-Z][a-z])/, "\1_\2")
+                    .gsub(/([a-z\d])([A-Z])/, "\1_\2")
+                    .tr("-", "_")
+                    .downcase
+          :"handle_#{handler}"
+        end
+        Actor.send(:define_method, method, &block)
+        @@system_events[self] = method
+      end
+    end
+
+    class LinkingEvent < SystemEvent
+      # Shared initializer for LinkingRequest and LinkingResponse
+      def initialize(actor, type)
+        @actor = actor
+        @type = type.to_sym
+        fail ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+      end
+    end
+  end
 
   # Request to link with another actor
-  class LinkingRequest < SystemEvent
+  class LinkingRequest < SystemEvent::LinkingEvent
     attr_reader :actor, :type
 
-    def initialize(actor, type)
-      @actor, @type = actor, type.to_sym
-      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+    handler do |event|
+      event.process(links)
     end
 
     def process(links)
@@ -22,21 +62,22 @@ module Celluloid
   end
 
   # Response to a link request
-  class LinkingResponse
+  class LinkingResponse < SystemEvent::LinkingEvent
     attr_reader :actor, :type
-
-    def initialize(actor, type)
-      @actor, @type = actor, type.to_sym
-      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
-    end
   end
 
   # An actor has exited for the given reason
   class ExitEvent < SystemEvent
     attr_reader :actor, :reason
 
+    handler do |event|
+      @links.delete event.actor
+      @exit_handler.call(event)
+    end
+
     def initialize(actor, reason = nil)
-      @actor, @reason = actor, reason
+      @actor = actor
+      @reason = reason
     end
   end
 
@@ -44,21 +85,35 @@ module Celluloid
   class NamingRequest < SystemEvent
     attr_reader :name
 
+    handler do |event|
+      @name = event.name
+      Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+    end
+
     def initialize(name)
       @name = name
     end
   end
 
   # Request for an actor to terminate
-  class TerminationRequest < SystemEvent; end
+  class TerminationRequest < SystemEvent
+    handler do |event|
+      terminate
+    end
+  end
 
   # Signal a condition
   class SignalConditionRequest < SystemEvent
     def initialize(task, value)
-      @task, @value = task, value
+      @task = task
+      @value = value
     end
     attr_reader :task, :value
 
+    handler do |event|
+      event.call
+    end
+
     def call
       @task.resume(@value)
     end

data/lib/celluloid/task/fibered.rb

@@ -0,0 +1,45 @@
+module Celluloid
+  class Task
+    # Tasks with a Fiber backend
+    class Fibered < Task
+      class StackError < Celluloid::Error; end
+      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
+          # TODO: Determine why infinite thread leakage happens under jRuby, if `Fiber.yield` is used:
+          Fiber.yield unless RUBY_PLATFORM == "java"
+        end
+      end
+
+      def signal
+        Fiber.yield
+      end
+
+      # Resume a suspended task, giving it a value to return if needed
+      def deliver(value)
+        @fiber.resume value
+      rescue SystemStackError => ex
+        raise StackError, "#{ex} @#{meta[:method_name] || :unknown} (see https://github.com/celluloid/celluloid/wiki/Fiber-stack-errors)"
+      rescue FiberError => ex
+        raise DeadTaskError, "cannot resume a dead task (#{ex})"
+      end
+
+      # Terminate this task
+      def terminate
+        super
+      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::Task::Threaded` if you need backtraces here."]
+      end
+    end
+  end
+end

data/lib/celluloid/task/threaded.rb

@@ -0,0 +1,59 @@
+module Celluloid
+  class Task
+    # Tasks with a Thread backend
+    class Threaded < Task
+      # Run the given block within a task
+      def initialize(type, meta)
+        @resume_queue = Queue.new
+        @exception_queue = Queue.new
+        @yield_mutex  = Mutex.new
+        @yield_cond   = ConditionVariable.new
+        @thread = nil
+
+        super
+      end
+
+      def create
+        # TODO: move this to ActorSystem#get_thread (ThreadHandle inside Group::Pool)
+        thread = Internals::ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
+          begin
+            ex = @resume_queue.pop
+            fail ex if ex.is_a?(TaskTerminated)
+
+            yield
+          rescue ::Exception => ex
+            @exception_queue << ex
+          ensure
+            @yield_mutex.synchronize do
+              @yield_cond.signal
+            end
+          end
+        end
+        @thread = thread
+      end
+
+      def signal
+        @yield_mutex.synchronize do
+          @yield_cond.signal
+        end
+        @resume_queue.pop
+      end
+
+      def deliver(value)
+        fail DeadTaskError, "cannot resume a dead task" unless @thread.alive?
+
+        @yield_mutex.synchronize do
+          @resume_queue.push(value)
+          @yield_cond.wait(@yield_mutex)
+          fail @exception_queue.pop while @exception_queue.size > 0
+        end
+      rescue ThreadError
+        raise DeadTaskError, "cannot resume a dead task"
+      end
+
+      def backtrace
+        @thread.backtrace
+      end
+    end
+  end
+end

data/lib/celluloid/{tasks.rb → task.rb}

@@ -1,22 +1,9 @@
 module Celluloid
-  # Asked to do task-related things outside a task
-  class NotTaskError < Celluloid::Error; end
-
-  # Trying to resume a dead task
-  class DeadTaskError < Celluloid::Error; end
-
-  # Errors which should be resumed automatically
-  class ResumableError < Celluloid::Error; end
-
   # Tasks are interruptable/resumable execution contexts used to run methods
   class Task
-    class TerminatedError < ResumableError; end # kill a running task after terminate
-
-    class TimeoutError < ResumableError; end # kill a running task after timeout
-
     # Obtain the current task
     def self.current
-      Thread.current[:celluloid_task] or raise NotTaskError, "not within a task context"
+      Thread.current[:celluloid_task] || fail(NotTaskError, "not within a task context")
     end
 
     # Suspend the running task, deferring to the scheduler
@@ -34,13 +21,13 @@ module Celluloid
       @status   = :new
 
       @exclusive         = false
-      @dangerous_suspend = @meta ? @meta.delete(:dangerous_suspend) : false
+      @dangerous_suspend = @meta ? @meta.dup.delete(:dangerous_suspend) : false
       @guard_warnings    = false
 
       actor     = Thread.current[:celluloid_actor]
-      @chain_id = CallChain.current_id
+      @chain_id = Internals::CallChain.current_id
 
-      raise NotActorError, "can't create tasks outside of actors" unless actor
+      fail NotActorError, "can't create tasks outside of actors" unless actor
       guard "can't create tasks inside of tasks" if Thread.current[:celluloid_task]
 
       create do
@@ -51,11 +38,11 @@ module Celluloid
           name_current_thread thread_metadata
 
           Thread.current[:celluloid_task] = self
-          CallChain.current_id = @chain_id
+          Internals::CallChain.current_id = @chain_id
 
           actor.tasks << self
           yield
-        rescue Task::TerminatedError
+        rescue TaskTerminated
           # Task was explicitly terminated
         ensure
           name_current_thread nil
@@ -65,19 +52,19 @@ module Celluloid
       end
     end
 
-    def create(&block)
-      raise "Implement #{self.class}#create"
+    def create(&_block)
+      fail "Implement #{self.class}#create"
     end
 
     # Suspend the current task, changing the status to the given argument
     def suspend(status)
-      raise "Cannot suspend while in exclusive mode" if exclusive?
-      raise "Cannot suspend a task from outside of itself" unless Task.current == self
+      fail "Cannot suspend while in exclusive mode" if exclusive?
+      fail "Cannot suspend a task from outside of itself" unless Task.current == self
 
       @status = status
 
       if $CELLULOID_DEBUG && @dangerous_suspend
-        Logger.with_backtrace(caller[2...8]) do |logger|
+        Internals::Logger.with_backtrace(caller[2...8]) do |logger|
           logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
         end
       end
@@ -85,15 +72,18 @@ module Celluloid
       value = signal
 
       @status = :running
-      raise value if value.is_a?(Celluloid::ResumableError)
-
+      fail value if value.is_a?(Celluloid::Interruption)
       value
     end
 
     # Resume a suspended task, giving it a value to return if needed
     def resume(value = nil)
       guard "Cannot resume a task from inside of a task" if Thread.current[:celluloid_task]
-      deliver(value)
+      if running?
+        deliver(value)
+      else
+        Internals::Logger.warn "Attempted to resume a dead task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+      end
       nil
     end
 
@@ -113,17 +103,20 @@ module Celluloid
 
     # Terminate this task
     def terminate
-      raise "Cannot terminate an exclusive task" if exclusive?
+      fail "Cannot terminate an exclusive task" if exclusive?
 
       if running?
-        Logger.with_backtrace(backtrace) do |logger|
-          logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        if $CELLULOID_DEBUG
+          Internals::Logger.with_backtrace(backtrace) do |logger|
+            type = @dangerous_suspend ? :warn : :debug
+            logger.send(type, "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}")
+          end
         end
-        exception = Task::TerminatedError.new("task was terminated")
+        exception = TaskTerminated.new("task was terminated")
         exception.set_backtrace(caller)
         resume exception
       else
-        raise DeadTaskError, "task is already dead"
+        fail DeadTaskError, "task is already dead"
       end
     end
 
@@ -136,7 +129,9 @@ module Celluloid
     end
 
     # Is the current task still running?
-    def running?; @status != :dead; end
+    def running?
+      @status != :dead
+    end
 
     # Nicer string inspect for tasks
     def inspect
@@ -145,9 +140,9 @@ module Celluloid
 
     def guard(message)
       if @guard_warnings
-        Logger.warn message if $CELLULOID_DEBUG
+        Internals::Logger.warn message if $CELLULOID_DEBUG
       else
-        raise message if $CELLULOID_DEBUG
+        fail message if $CELLULOID_DEBUG
       end
     end
 
@@ -171,6 +166,3 @@ module Celluloid
     end
   end
 end
-
-require 'celluloid/tasks/task_fiber'
-require 'celluloid/tasks/task_thread'

data/lib/celluloid/test.rb

@@ -1,3 +1,3 @@
 $CELLULOID_TEST = true
 
-require 'celluloid'
+require "celluloid"

data/lib/celluloid/thread.rb

@@ -1,4 +1,4 @@
-require 'celluloid/fiber'
+require "celluloid/fiber"
 
 module Celluloid
   class Thread < ::Thread
@@ -36,5 +36,10 @@ module Celluloid
     def call_chain_id
       self[:celluloid_chain_id]
     end
+
+    def <<(proc)
+      self[:celluloid_queue] << proc
+      self
+    end
   end
 end

data/lib/celluloid/version.rb

@@ -0,0 +1,3 @@
+module Celluloid
+  VERSION = "0.17.3"
+end