celluloid 0.11.1 → 0.12.0.pre

data/lib/celluloid/system_events.rb

@@ -0,0 +1,54 @@
+module Celluloid
+  # High-priority internal system events
+  class SystemEvent; end
+
+  # Request to link with another actor
+  class LinkingRequest < SystemEvent
+    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
+
+    def process(links)
+      case type
+      when :link   then links << actor
+      when :unlink then links.delete actor
+      end
+
+      actor.mailbox << LinkingResponse.new(Actor.current, type)
+    end
+  end
+
+  # Response to a link request
+  class LinkingResponse
+    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
+
+    def initialize(actor, reason = nil)
+      @actor, @reason = actor, reason
+    end
+  end
+
+  # Name an actor at the time it's registered
+  class NamingRequest < SystemEvent
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  # Request for an actor to terminate
+  class TerminationRequest < SystemEvent; end
+end

data/lib/celluloid/task.rb

@@ -1,78 +1,22 @@
+require 'celluloid/tasks/task_fiber'
+require 'celluloid/tasks/task_thread'
+
 module Celluloid
   # Trying to resume a dead task
   class DeadTaskError < StandardError; end
 
   # Tasks are interruptable/resumable execution contexts used to run methods
-  class Task
-    class TerminatedError < StandardError; end # kill a running fiber
-
-    attr_reader   :type
-    attr_accessor :status
+  module Task
+    class TerminatedError < StandardError; end # kill a running task
 
     # Obtain the current task
     def self.current
-      Fiber.current.task or raise "no task for this Fiber"
+      Thread.current[:task] or raise "not within a task context"
     end
 
     # Suspend the running task, deferring to the scheduler
     def self.suspend(status)
-      task = Task.current
-      task.status = status
-
-      result = Fiber.yield
-      raise TerminatedError, "task was terminated" if result == TerminatedError
-      task.status = :running
-
-      result
-    end
-
-    # Run the given block within a task
-    def initialize(type)
-      @type   = type
-      @status = :new
-
-      actor   = Thread.current[:actor]
-      mailbox = Thread.current[:mailbox]
-
-      @fiber = Fiber.new do
-        @status = :running
-        Thread.current[:actor]   = actor
-        Thread.current[:mailbox] = mailbox
-        Fiber.current.task = self
-        actor.tasks << self
-
-        begin
-          yield
-        rescue TerminatedError
-          # Task was explicitly terminated
-        ensure
-          @status = :dead
-          actor.tasks.delete self
-        end
-      end
-    end
-
-    # Resume a suspended task, giving it a value to return if needed
-    def resume(value = nil)
-      @fiber.resume value
-      nil
-    rescue FiberError
-      raise DeadTaskError, "cannot resume a dead task"
-    end
-
-    # Terminate this task
-    def terminate
-      resume TerminatedError if @fiber.alive?
-    rescue FiberError
-      # If we're getting this the task should already be dead
-    end
-
-    # Is the current task still running?
-    def running?; @fiber.alive?; end
-
-    # Nicer string inspect for tasks
-    def inspect
-      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}, @running=#{@fiber.alive?}>"
+      Task.current.suspend(status)
     end
   end
 end

data/lib/celluloid/tasks/task_fiber.rb

@@ -0,0 +1,65 @@
+module Celluloid
+  # Tasks with a Fiber backend
+  class TaskFiber
+    attr_reader :type, :status
+
+    # Run the given block within a task
+    def initialize(type)
+      @type   = type
+      @status = :new
+
+      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      raise NotActorError, "can't create tasks outside of actors" unless actor
+
+      @fiber = Fiber.new do
+        @status = :running
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+        Thread.current[:task]    = self
+        actor.tasks << self
+
+        begin
+          yield
+        rescue Task::TerminatedError
+          # Task was explicitly terminated
+        ensure
+          @status = :dead
+          actor.tasks.delete self
+        end
+      end
+    end
+
+    # Suspend the current task, changing the status to the given argument
+    def suspend(status)
+      @status = status
+      result = Fiber.yield
+      raise result if result.is_a?(Task::TerminatedError)
+      @status = :running
+
+      result
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      @fiber.resume value
+      nil
+    rescue FiberError
+      raise DeadTaskError, "cannot resume a dead task"
+    end
+
+    # Terminate this task
+    def terminate
+      resume Task::TerminatedError.new("task was terminated") if @fiber.alive?
+    rescue FiberError
+      # If we're getting this the task should already be dead
+    end
+
+    # Is the current task still running?
+    def running?; @fiber.alive?; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
+    end
+  end
+end

data/lib/celluloid/tasks/task_thread.rb

@@ -0,0 +1,70 @@
+module Celluloid
+  # Tasks with a Thread backend
+  class TaskThread
+    attr_reader :type, :status
+
+    # Run the given block within a task
+    def initialize(type)
+      @type   = type
+      @status = :new
+      @yield  = Queue.new
+      @resume = Queue.new
+
+      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      raise NotActorError, "can't create tasks outside of actors" unless actor
+
+      @thread = InternalPool.get do
+        @status = :running
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+        Thread.current[:task]    = self
+        actor.tasks << self
+
+        begin
+          @yield.push(yield(@resume.pop))
+        rescue Task::TerminatedError
+          # Task was explicitly terminated
+        ensure
+          @status = :dead
+          actor.tasks.delete self
+          @waiter.run if @waiter
+        end
+      end
+    end
+
+    # Suspend the current task, changing the status to the given argument
+    def suspend(status)
+      @status = status
+      @yield.push(nil)
+      result = @resume.pop
+
+      raise result if result.is_a?(Task::TerminatedError)
+      @status = :running
+
+      result
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
+      @resume.push(value)
+      @yield.pop
+      nil
+    rescue ThreadError
+      raise DeadTaskError, "cannot resume a dead task"
+    end
+
+    # Terminate this task
+    def terminate
+      resume Task::TerminatedError.new("task was terminated") if @thread.alive?
+    end
+
+    # Is the current task still running?
+    def running?; @status != :dead; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
+    end
+  end
+end

data/lib/celluloid/thread_handle.rb

@@ -27,12 +27,13 @@ module Celluloid
     # Forcibly kill the thread
     def kill
       !!@mutex.synchronize { @thread.kill if @thread }
+      self
     end
 
     # Join to a running thread, blocking until it terminates
     def join
       @mutex.synchronize { @join.wait(@mutex) if @thread }
-      nil
+      self
     end
   end
 end

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.11.1'
+  VERSION = '0.12.0.pre'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -19,11 +19,22 @@ shared_context "a Celluloid Actor" do |included_module|
     end.should be_true
   end
 
+  it "can be stored in hashes" do
+    actor = actor_class.new "Troy McClure"
+    actor.hash.should_not == Kernel.hash
+    actor.object_id.should_not == Kernel.object_id
+  end
+
   it "handles synchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.greet.should == "Hi, I'm Troy McClure"
   end
 
+  it "handles synchronous calls via #method" do
+    method = actor_class.new("Troy McClure").method(:greet)
+    method.call.should == "Hi, I'm Troy McClure"
+  end
+
   it "handles futures for synchronous calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
@@ -54,6 +65,12 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.first.should be == :bar
   end
 
+  it "properly handles respond_to with include_private" do
+    actor = actor_class.new "Method missing privates"
+    actor.respond_to?(:zomg_private).should be_false
+    actor.respond_to?(:zomg_private, true).should be_true
+  end
+
   it "raises NoMethodError when a nonexistent method is called" do
     actor = actor_class.new "Billy Bob Thornton"
 
@@ -193,15 +210,15 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = actor_class.new "Arnold Schwarzenegger"
       actor.should be_alive
       actor.terminate
-      actor.join
+      Celluloid::Actor.join(actor)
       actor.should_not be_alive
     end
 
     it "kills" do
       actor = actor_class.new "Woody Harrelson"
       actor.should be_alive
-      actor.kill
-      actor.join
+      Celluloid::Actor.kill(actor)
+      Celluloid::Actor.join(actor)
       actor.should_not be_alive
     end
 
@@ -213,6 +230,15 @@ shared_context "a Celluloid Actor" do |included_module|
         actor.greet
       end.to raise_exception(Celluloid::DeadActorError)
     end
+
+    it "raises the right DeadActorError if terminate! called after terminated" do
+      actor = actor_class.new "Arnold Schwarzenegger"
+      actor.terminate
+
+      expect do
+        actor.terminate!
+      end.to raise_exception(Celluloid::DeadActorError, "actor already terminated")
+    end
   end
 
   context :current_actor do
@@ -236,16 +262,39 @@ shared_context "a Celluloid Actor" do |included_module|
 
     it "links to other actors" do
       @kevin.link @charlie
-      @kevin.linked_to?(@charlie).should be_true
-      @charlie.linked_to?(@kevin).should be_true
+      @kevin.monitoring?(@charlie).should be_true
+      @kevin.linked_to?(@charlie).should  be_true
+      @charlie.monitoring?(@kevin).should be_true
+      @charlie.linked_to?(@kevin).should  be_true
     end
 
     it "unlinks from other actors" do
       @kevin.link @charlie
       @kevin.unlink @charlie
 
-      @kevin.linked_to?(@charlie).should be_false
-      @charlie.linked_to?(@kevin).should be_false
+      @kevin.monitoring?(@charlie).should be_false
+      @kevin.linked_to?(@charlie).should  be_false
+      @charlie.monitoring?(@kevin).should be_false
+      @charlie.linked_to?(@kevin).should  be_false
+    end
+
+    it "monitors other actors unidirectionally" do
+      @kevin.monitor @charlie
+
+      @kevin.monitoring?(@charlie).should be_true
+      @kevin.linked_to?(@charlie).should  be_false
+      @charlie.monitoring?(@kevin).should be_false
+      @charlie.linked_to?(@kevin).should  be_false
+    end
+
+    it "unmonitors other actors" do
+      @kevin.monitor @charlie
+      @kevin.unmonitor @charlie
+
+      @kevin.monitoring?(@charlie).should be_false
+      @kevin.linked_to?(@charlie).should  be_false
+      @charlie.monitoring?(@kevin).should be_false
+      @charlie.linked_to?(@kevin).should  be_false
     end
 
     it "traps exit messages from other actors" do
@@ -357,6 +406,38 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context "exclusive classes" do
+    subject do
+      Class.new do
+        include included_module
+        exclusive
+
+        attr_reader :tasks
+
+        def initialize
+          @tasks = []
+        end
+
+        def eat_donuts
+          sleep Q
+          @tasks << 'donuts'
+        end
+
+        def drink_coffee
+          @tasks << 'coffee'
+        end
+      end
+    end
+
+    it "executes two methods in an exclusive order" do
+      actor = subject.new
+      actor.eat_donuts!
+      actor.drink_coffee!
+      sleep Q * 2
+      actor.tasks.should == ['donuts', 'coffee']
+    end
+  end
+
   context :receiving do
     before do
       @receiver = Class.new do
@@ -526,7 +607,7 @@ shared_context "a Celluloid Actor" do |included_module|
       tasks.size.should == 2
 
       blocking_task = tasks.find { |t| t.status != :running }
-      blocking_task.should be_a Celluloid::Task
+      blocking_task.should be_a Celluloid.task_class
       blocking_task.status.should == :callwait
 
       actor.blocker.unblock
@@ -534,4 +615,39 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.tasks.size.should == 1
     end
   end
+
+  context :use_mailbox do
+    class ExampleMailbox < Celluloid::Mailbox; end
+
+    subject do
+      Class.new do
+        include included_module
+        use_mailbox ExampleMailbox
+      end
+    end
+
+    it "uses user-specified mailboxes" do
+      subject.new.mailbox.should be_a ExampleMailbox
+    end
+
+    it "retains custom mailboxes when subclassed" do
+      subclass = Class.new(subject)
+      subclass.new.mailbox.should be_a ExampleMailbox
+    end
+  end
+
+  context :task_class do
+    class ExampleTask < Celluloid::TaskFiber; end
+
+    subject do
+      Class.new do
+        include included_module
+        task_class ExampleTask
+      end
+    end
+
+    it "uses user-specified tasks" do
+      subject.new.tasks.first.should be_a ExampleTask
+    end
+  end
 end