celluloid 0.16.0 → 0.17.0

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} (please 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?(Task::TerminatedError)
+
+            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/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.0"
+end

data/spec/celluloid/actor_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid, actor_system: :global do
+RSpec.describe Celluloid do
   it_behaves_like "a Celluloid Actor", Celluloid
 end

data/spec/celluloid/actor_system_spec.rb

@@ -1,47 +1,62 @@
-require 'spec_helper'
-
-describe Celluloid::ActorSystem do
+RSpec.describe Celluloid::ActorSystem do
   class TestActor
     include Celluloid
+    def identity
+      :testing
+    end
+  end
+
+  after do
+    subject.shutdown
   end
 
   it "supports non-global ActorSystem" do
     subject.within do
-      Celluloid.actor_system.should == subject
+      expect(Celluloid.actor_system).to eq(subject)
     end
   end
 
-  it "starts default actors" do
+  it "makes actors accessible by Celluloid[:actor]" do
     subject.start
+    subject.within do
+      TestActor.supervise as: :testing, type: TestActor
+      expect(subject.registered).to include(:testing)
+      expect(Celluloid::Actor[:testing].identity).to eq(:testing)
+    end
+  end
 
-    subject.registered.should == [:notifications_fanout, :default_incident_reporter]
+  it "starts default actors" do
+    subject.start
+    expect(subject.registered).to eq(Celluloid::ActorSystem::ROOT_SERVICES.map { |r| r[:as] })
   end
 
   it "support getting threads" do
     queue = Queue.new
-    thread = subject.get_thread do
-      Celluloid.actor_system.should == subject
+    subject.get_thread do
+      expect(Celluloid.actor_system).to eq(subject)
       queue << nil
     end
     queue.pop
   end
 
   it "allows a stack dump" do
-    subject.stack_dump.should be_a(Celluloid::StackDump)
+    expect(subject.stack_dump).to be_a(Celluloid::Internals::Stack::Dump)
   end
 
-  it "returns named actors" do
-    subject.registered.should be_empty
+  it "allows a stack summary" do
+    expect(subject.stack_summary).to be_a(Celluloid::Internals::Stack::Summary)
+  end
 
+  it "returns named actors" do
+    subject.start
     subject.within do
-      TestActor.supervise_as :test
+      TestActor.supervise as: :test
     end
-
-    subject.registered.should == [:test]
+    expect(subject.registered).to include(:test)
   end
 
   it "returns running actors" do
-    subject.running.should be_empty
+    expect(subject.running).to be_empty
 
     first = subject.within do
       TestActor.new
@@ -51,19 +66,18 @@ describe Celluloid::ActorSystem do
       TestActor.new
     end
 
-    subject.running.should == [first, second]
+    expect(subject.running).to eq([first, second])
   end
 
   it "shuts down" do
     subject.shutdown
 
-    lambda { subject.get_thread }.
-      should raise_error("Thread pool is not running")
+    expect { subject.get_thread }
+      .to raise_error(Celluloid::Group::NotActive)
   end
 
   it "warns nicely when no actor system is started" do
-    lambda { TestActor.new }.
-      should raise_error("Celluloid is not yet started; use Celluloid.boot")
+    expect { TestActor.new }
+      .to raise_error("Celluloid is not yet started; use Celluloid.boot")
   end
-
 end

data/spec/celluloid/block_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe "Blocks", actor_system: :global do
+RSpec.describe "Blocks", actor_system: :global do
   class MyBlockActor
     include Celluloid
 
@@ -14,7 +12,7 @@ describe "Blocks", actor_system: :global do
       $data << [:outside, @name, current_actor.name]
       other.do_something_and_callback do |value|
         $data << [:yielded, @name, current_actor.name]
-        $data << self.receive_result(:self)
+        $data << receive_result(:self)
         $data << current_actor.receive_result(:current_actor)
         $data << sender_actor.receive_result(:sender)
         "somevalue"
@@ -49,6 +47,6 @@ describe "Blocks", actor_system: :global do
       "somevalue",
     ]
 
-    $data.should eq(expected)
+    expect($data).to eq(expected)
   end
 end

data/spec/celluloid/calls_spec.rb

@@ -1,6 +1,5 @@
-require 'spec_helper'
-
-describe Celluloid::SyncCall, actor_system: :global do
+RSpec.describe Celluloid::Call::Sync, actor_system: :global do
+  # TODO: these should be Call::Sync unit tests (without working on actual actors)
   class CallExampleActor
     include Celluloid
 
@@ -10,33 +9,56 @@ describe Celluloid::SyncCall, actor_system: :global do
 
     def actual_method; end
 
+    def inspect
+      fail "Don't call!"
+    end
+
     def chained_call_ids
       [call_chain_id, @next.call_chain_id]
     end
   end
 
   let(:actor) { CallExampleActor.new }
+  let(:logger) { Specs::FakeLogger.current }
 
-  it "aborts with NoMethodError when a nonexistent method is called" do
-    expect do
-      actor.the_method_that_wasnt_there
-    end.to raise_exception(NoMethodError)
+  context "when obj does not respond to a method" do
+    # bypass this until rubinius/rubinius#3373 is resolved
+    # under Rubinius, `method` calls `inspect` on an object when a method is not found
+    unless RUBY_ENGINE == "rbx"
+      it "raises a NoMethodError" do
+        allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
+
+        expect do
+          actor.the_method_that_wasnt_there
+        end.to raise_exception(NoMethodError)
+      end
+    end
+
+    context "when obj raises during inspect" do
+      it "should emulate obj.inspect" do
+        allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
 
-    actor.should be_alive
+        if RUBY_ENGINE == "rbx"
+          expected = /undefined method `no_such_method' on an instance of CallExampleActor/
+        else
+          expected = /undefined method `no_such_method' for #\<CallExampleActor:0x[a-f0-9]+\>/
+        end
+      end
+    end
   end
 
   it "aborts with ArgumentError when a method is called with too many arguments" do
+    allow(logger).to receive(:crash).with("Actor crashed!", ArgumentError)
+
     expect do
       actor.actual_method("with too many arguments")
     end.to raise_exception(ArgumentError)
-
-    actor.should be_alive
   end
 
   it "preserves call chains across synchronous calls" do
     actor2 = CallExampleActor.new(actor)
 
     uuid, next_actor_uuid = actor2.chained_call_ids
-    uuid.should eq next_actor_uuid
+    expect(uuid).to eq next_actor_uuid
   end
 end

data/spec/celluloid/condition_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+RSpec.describe Celluloid::Condition, actor_system: :global do
+  let(:logger) { Specs::FakeLogger.current }
 
-describe Celluloid::Condition, actor_system: :global do
   class ConditionExample
     include Celluloid
 
@@ -29,7 +29,9 @@ describe Celluloid::Condition, actor_system: :global do
       value
     end
 
-    def waiting?; @waiting end
+    def waiting?
+      @waiting
+    end
   end
 
   let(:actor) { ConditionExample.new }
@@ -37,40 +39,41 @@ describe Celluloid::Condition, actor_system: :global do
 
   it "sends signals" do
     3.times { actor.async.wait_for_condition }
-    actor.signaled_times.should be_zero
+    expect(actor.signaled_times).to be_zero
 
     actor.condition.signal
-    actor.signaled_times.should be(1)
+    expect(actor.signaled_times).to be(1)
   end
 
   it "broadcasts signals" do
     3.times { actor.async.wait_for_condition }
-    actor.signaled_times.should be_zero
+    expect(actor.signaled_times).to be_zero
 
     actor.condition.broadcast
-    actor.signaled_times.should be(3)
+    expect(actor.signaled_times).to be(3)
   end
 
   it "sends values along with signals" do
     future = actor.future(:wait_for_condition)
     actor.condition.signal(:example_value)
-    future.value.should be(:example_value)
+    expect(future.value).to be(:example_value)
   end
 
   it "supports waiting outside actors" do
     condition = Celluloid::Condition.new
     actor.async.signal_condition condition, :value
-    condition.wait.should eq(:value)
+    expect(condition.wait).to eq(:value)
   end
 
   it "times out inside normal Threads" do
     condition = Celluloid::Condition.new
-    lambda { condition.wait(1) }.
-      should raise_error(Celluloid::ConditionError)
+    expect { condition.wait(1) }
+      .to raise_error(Celluloid::ConditionError)
   end
 
   it "times out inside Tasks" do
-    lambda { actor.wait_for_condition(1) }.
-      should raise_error(Celluloid::ConditionError)
+    allow(logger).to receive(:crash).with("Actor crashed!", Celluloid::ConditionError)
+    expect { actor.wait_for_condition(1) }
+      .to raise_error(Celluloid::ConditionError)
   end
 end

data/spec/celluloid/evented_mailbox_spec.rb

@@ -1,34 +1,4 @@
-require 'spec_helper'
-
-class TestEventedMailbox < Celluloid::EventedMailbox
-  class Reactor
-    def initialize
-      @condition = ConditionVariable.new
-      @mutex = Mutex.new
-    end
-
-    def wakeup
-      @mutex.synchronize do
-        @condition.signal
-      end
-    end
-
-    def run_once(timeout)
-      @mutex.synchronize do
-        @condition.wait(@mutex, timeout)
-      end
-    end
-
-    def shutdown
-    end
-  end
-
-  def initialize
-    super(Reactor)
-  end
-end
-
-describe Celluloid::EventedMailbox do
+RSpec.describe Celluloid::Mailbox::Evented do
   subject { TestEventedMailbox.new }
   it_behaves_like "a Celluloid Mailbox"
 end