celluloid 0.17.4 → 0.18.0

data/spec/celluloid/supervision/supervisor_spec.rb

@@ -0,0 +1,93 @@
+RSpec.describe "Celluloid supervisor", actor_system: :global do
+  let(:logger) { Specs::FakeLogger.current }
+
+  it "restarts actors when they die" do
+    supervisor = Celluloid.supervise(type: Subordinate, args: [:idle])
+    subordinate = supervisor.actors.first
+    expect(subordinate.state).to be(:idle)
+
+    subordinate.crack_the_whip
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = supervisor.actors.first
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to eq :idle
+  end
+
+  it "registers actors and reregisters them when they die" do
+    Celluloid.supervise(as: :subordinate, type: Subordinate, args: [:idle])
+    subordinate = Celluloid::Actor[:subordinate]
+    expect(subordinate.state).to be(:idle)
+
+    subordinate.crack_the_whip
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = Celluloid::Actor[:subordinate]
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to eq :idle
+  end
+
+  it "creates supervisors via Actor.supervise" do
+    supervisor = Subordinate.supervise(args: [:working])
+    subordinate = supervisor.actors.first
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead, "the spec purposely crashed me :(")
+
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = supervisor.actors.first
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to eq :working
+  end
+
+  it "creates supervisors and registers actors via Actor.supervise as:" do
+    supervisor = Subordinate.supervise(as: :subordinate, args: [:working])
+    subordinate = Celluloid::Actor[:subordinate]
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = supervisor.actors.first
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to be(:working)
+  end
+
+  it "removes an actor if it terminates cleanly" do
+    supervisor = Subordinate.supervise(args: [:working])
+    subordinate = supervisor.actors.first
+
+    expect(supervisor.actors).to eq([subordinate])
+
+    subordinate.terminate
+
+    expect(supervisor.actors).to be_empty
+  end
+end

data/spec/celluloid/task/fibered_spec.rb

@@ -1,5 +1,3 @@
 RSpec.describe Celluloid::Task::Fibered, actor_system: :within do
-  if Celluloid.task_class == Celluloid::Task::Fibered
-    it_behaves_like "a Celluloid Task"
-  end
+  it_behaves_like "a Celluloid Task" if Celluloid.task_class == Celluloid::Task::Fibered
 end

data/spec/celluloid/task/threaded_spec.rb

@@ -1,5 +1,3 @@
 RSpec.describe Celluloid::Task::Threaded, actor_system: :within do
-  if Celluloid.task_class == Celluloid::Task::Threaded
-    it_behaves_like "a Celluloid Task"
-  end
+  it_behaves_like "a Celluloid Task" if Celluloid.task_class == Celluloid::Task::Threaded
 end

data/spec/shared/actor_examples.rb

@@ -2,7 +2,7 @@ RSpec.shared_examples "a Celluloid Actor" do
   around do |ex|
     Celluloid.boot
     ex.run
-    Celluloid.shutdown
+    Celluloid.shutdown if Celluloid.running?
   end
 
   let(:task_klass) { Celluloid.task_class }
@@ -11,6 +11,12 @@ RSpec.shared_examples "a Celluloid Actor" do
 
   let(:logger) { Specs::FakeLogger.current }
 
+  it "doesn't raise an error when rebooting" do
+    Celluloid.shutdown
+
+    expect { Celluloid.boot }.to change { Celluloid.running? }.from(false).to(true)
+  end
+
   it "returns the actor's class, not the proxy's" do
     expect(actor.class).to eq(actor_class)
   end
@@ -22,24 +28,24 @@ RSpec.shared_examples "a Celluloid Actor" do
         true
       else
         false
-      end,
+      end
     ).to be_truthy
   end
 
   it "can be stored in hashes" do
     expect(actor.hash).not_to eq(Kernel.hash)
     expect(actor.object_id).not_to eq(Kernel.object_id)
-    expect(actor.eql? actor).to be_truthy
+    expect(actor.eql?(actor)).to be_truthy
   end
 
   it "can be stored in hashes even when dead" do
     actor.terminate
-    
+
     expect(actor.dead?).to be_truthy
-    
+
     expect(actor.hash).not_to eq(Kernel.hash)
     expect(actor.object_id).not_to eq(Kernel.object_id)
-    expect(actor.eql? actor).to be_truthy
+    expect(actor.eql?(actor)).to be_truthy
   end
 
   it "implements respond_to? correctly" do
@@ -201,7 +207,9 @@ RSpec.shared_examples "a Celluloid Actor" do
     end
 
     it "warns about suspending the initialize" do
+      # rubocop:disable Metrics/LineLength
       expect(logger).to receive(:warn).with(/Dangerously suspending task: type=:call, meta={:dangerous_suspend=>true, :method_name=>:initialize}, status=:sleeping/)
+      # rubocop:enable Metrics/LineLength
 
       actor.terminate
       Specs.sleep_and_wait_until { !actor.alive? }
@@ -232,7 +240,9 @@ RSpec.shared_examples "a Celluloid Actor" do
     it "warns about suspending the finalizer" do
       allow(logger).to receive(:warn)
       allow(logger).to receive(:crash).with(/finalizer crashed!/, Celluloid::TaskTerminated)
+      # rubocop:disable Metrics/LineLength
       expect(logger).to receive(:warn).with(/Dangerously suspending task: type=:finalizer, meta={:dangerous_suspend=>true, :method_name=>:cleanup}, status=:sleeping/)
+      # rubocop:enable Metrics/LineLength
       actor.terminate
       Specs.sleep_and_wait_until { !actor.alive? }
     end
@@ -418,7 +428,7 @@ RSpec.shared_examples "a Celluloid Actor" do
           include CelluloidSpecs.included_module
 
           define_method(:receiver_method) do
-            fail ExampleCrash, "the spec purposely crashed me :("
+            raise ExampleCrash, "the spec purposely crashed me :("
           end
         end.new
 
@@ -430,18 +440,16 @@ RSpec.shared_examples "a Celluloid Actor" do
           end
         end.new
 
-        ex = example_caller.sender_method rescue $ERROR_INFO
-        Specs.sleep_and_wait_until { !example_caller.alive? }
-        Specs.sleep_and_wait_until { !example_receiver.alive? }
-
-        expect(ex).to be_a ExampleCrash
-        expect(ex.backtrace.grep(/`sender_method'/)).to be_truthy
-        expect(ex.backtrace.grep(/`receiver_method'/)).to be_truthy
+        expect { example_caller.sender_method }.to raise_error ExampleCrash
       end
 
       it "raises DeadActorError if methods are synchronously called on a dead actor" do
         allow(logger).to receive(:crash).with("Actor crashed!", ExampleCrash)
-        actor.crash rescue ExampleCrash
+        begin
+          actor.crash
+        rescue
+          ExampleCrash
+        end
 
         # TODO: avoid this somehow
         sleep 0.1 # hax to prevent a race between exit handling and the next call
@@ -469,10 +477,11 @@ RSpec.shared_examples "a Celluloid Actor" do
     end
 
     it "crashes the sender if we pass neither String nor Exception" do
+      number = 10
       allow(logger).to receive(:crash).with("Actor crashed!", TypeError)
       expect do
-        actor.crash_with_abort_raw 10
-      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
+        actor.crash_with_abort_raw number
+      end.to raise_exception(TypeError, "Exception object/String expected, but #{number.class} received")
 
       Specs.sleep_and_wait_until { !actor.alive? }
       expect(actor).not_to be_alive
@@ -550,7 +559,9 @@ RSpec.shared_examples "a Celluloid Actor" do
 
       context "when terminated" do
         it "logs a debug" do
+          # rubocop:disable Metrics/LineLength
           expect(logger).to receive(:debug).with(/^Terminating task: type=:call, meta={:dangerous_suspend=>false, :method_name=>:sleepy}, status=:sleeping/)
+          # rubocop:enable Metrics/LineLength
           actor.terminate
           Specs.sleep_and_wait_until { !actor.alive? }
         end
@@ -594,9 +605,9 @@ RSpec.shared_examples "a Celluloid Actor" do
           @subordinate_lambasted
         end
 
-        def lambaste_subordinate(_actor, _reason)
+        def lambaste_subordinate(_actor, reason)
           @subordinate_lambasted = true
-          @exception = _reason
+          @exception = reason
         end
       end
     end
@@ -704,7 +715,7 @@ RSpec.shared_examples "a Celluloid Actor" do
         end
 
         def wait_for_signal
-          fail "already signaled" if @signaled
+          raise "already signaled" if @signaled
 
           @waiting = true
           value = wait :ponycopter
@@ -801,14 +812,14 @@ RSpec.shared_examples "a Celluloid Actor" do
       subject.async.exclusive_with_block_log_task(:one)
       subject.async.log_task(:two)
       sleep Specs::TIMER_QUANTUM * 2
-      expect(subject.tasks).to eq([:one, :two])
+      expect(subject.tasks).to eq(%i[one two])
     end
 
     it "executes methods in the proper order with a class-level annotation" do
       subject.async.exclusive_log_task :one
       subject.async.log_task :two
       sleep Specs::TIMER_QUANTUM * 2
-      expect(subject.tasks).to eq([:one, :two])
+      expect(subject.tasks).to eq(%i[one two])
     end
 
     it "knows when it's in exclusive mode" do
@@ -854,7 +865,7 @@ RSpec.shared_examples "a Celluloid Actor" do
       end
 
       it "executes in an exclusive order" do
-        expect(actor.tasks).to eq(%w(donuts coffee))
+        expect(actor.tasks).to eq(%w[donuts coffee])
       end
     end
   end
@@ -949,7 +960,7 @@ RSpec.shared_examples "a Celluloid Actor" do
       expect(actor).to be_sleeping
 
       future.value
-      # I got 0.558 (in a slighly busy MRI) which is outside 0.05 of 0.5, so let's use (0.05 * 2)
+      # I got 0.558 (in a slightly busy MRI) which is outside 0.05 of 0.5, so let's use (0.05 * 2)
       expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM * 2).of interval
     end
 
@@ -1102,7 +1113,7 @@ RSpec.shared_examples "a Celluloid Actor" do
 
           klass = Class.new(Celluloid::Proxy::Cell) do
             def dividing_3_by(number)
-              fail ArgumentError, "<facepalm>" if number.zero?
+              raise ArgumentError, "<facepalm>" if number.zero?
               super
             end
           end
@@ -1121,7 +1132,11 @@ RSpec.shared_examples "a Celluloid Actor" do
         end
 
         it "does not crash the actor" do
-          subject.dividing_3_by(0) rescue ArgumentError
+          begin
+            subject.dividing_3_by(0)
+          rescue
+            ArgumentError
+          end
           expect(subject.dividing_3_by(3)).to eq(1)
         end
       end
@@ -1130,7 +1145,7 @@ RSpec.shared_examples "a Celluloid Actor" do
     context "when it includes method checking" do
       module MethodChecking
         def method_missing(meth, *args)
-          return super if [:__send__, :respond_to?, :method, :class, :__class__].include? meth
+          return super if %i[__send__ respond_to? method class __class__].include? meth
 
           unmet_requirement = nil
 
@@ -1141,7 +1156,7 @@ RSpec.shared_examples "a Celluloid Actor" do
             mandatory_args = -arity - 1
             unmet_requirement = "#{mandatory_args}+" if args.size < mandatory_args
           end
-          fail ArgumentError, "wrong number of arguments (#{args.size} for #{unmet_requirement})" if unmet_requirement
+          raise ArgumentError, "wrong number of arguments (#{args.size} for #{unmet_requirement})" if unmet_requirement
 
           super
         end
@@ -1160,7 +1175,7 @@ RSpec.shared_examples "a Celluloid Actor" do
           end
 
           def this_is_not_madness(word1, word2, word3, *_args)
-            fail "This is madness!" unless [word1, word2, word3] == [:this, :is, :Sparta]
+            raise "This is madness!" unless [word1, word2, word3] == %i[this is Sparta]
           end
 
           proxy_class klass
@@ -1173,7 +1188,11 @@ RSpec.shared_examples "a Celluloid Actor" do
         end
 
         it "does not crash the actor" do
-          subject.method_to_madness rescue NoMethodError
+          begin
+            subject.method_to_madness
+          rescue
+            NoMethodError
+          end
           expect(subject.madness).to eq("This is madness!")
         end
       end
@@ -1181,18 +1200,24 @@ RSpec.shared_examples "a Celluloid Actor" do
       context "when invoking a existing method with incorrect args" do
         context "with too many arguments" do
           it "raises an ArgumentError" do
-            expect { subject.madness(:Sparta) }.to raise_error(ArgumentError, "wrong number of arguments (1 for 0)")
+            expect { subject.madness(:Sparta) }
+              .to raise_error(ArgumentError, "wrong number of arguments (1 for 0)")
           end
 
           it "does not crash the actor" do
-            subject.madness(:Sparta) rescue ArgumentError
+            begin
+              subject.madness(:Sparta)
+            rescue
+              ArgumentError
+            end
             expect(subject.madness).to eq("This is madness!")
           end
         end
 
         context "with not enough mandatory arguments" do
           it "raises an ArgumentError" do
-            expect { subject.this_is_not_madness(:this, :is) }.to raise_error(ArgumentError, "wrong number of arguments (2 for 3+)")
+            expect { subject.this_is_not_madness(:this, :is) }
+              .to raise_error(ArgumentError, "wrong number of arguments (2 for 3+)")
           end
         end
       end

data/spec/shared/group_examples.rb

@@ -35,7 +35,7 @@ RSpec.shared_examples "a Celluloid Group" do
         subject.get do
           busy_queue << nil
           @wait_queue.pop
-          fail exception_class, "Error"
+          raise exception_class, "Error"
         end
 
         wait_until_busy(busy_queue)
@@ -89,7 +89,7 @@ RSpec.shared_examples "a Celluloid Group" do
       subject.get do
         thread << Thread.current
         sleep
-      end,
+      end
     ).to be_a(Celluloid::Thread)
 
     thread.pop # wait for 3rd-party thread to get strated

data/spec/shared/mailbox_examples.rb

@@ -62,7 +62,7 @@ RSpec.shared_examples "a Celluloid Mailbox" do
     subject << :first
     subject << :second
     subject << :third
-    expect(subject.to_a).to match_array([:first, :second])
+    expect(subject.to_a).to match_array(%i[first second])
   end
 
   it "logs discarded messages" do

data/spec/shared/stack_examples.rb

@@ -0,0 +1,87 @@
+RSpec.shared_examples "a Celluloid Stack" do
+  let(:actor_system) { Celluloid::Actor::System.new }
+  let(:threads) { Queue.new }
+
+  before(:each) do
+    items = 0
+
+    [Celluloid::Task::Fibered, Celluloid::Task::Threaded].each do |task_klass|
+      create_async_blocking_actor(task_klass)
+      items += 1
+    end
+
+    @active_thread = create_thread_with_role(threads, :other_thing)
+    items += 1
+
+    @idle_thread = create_thread_with_role(threads, :idle_thing)
+    items += 1
+
+    # StackWaiter for each thread to add itself to the queue
+    tmp = Queue.new
+    items.times do
+      th = Timeout.timeout(4) { threads.pop }
+      tmp << th
+    end
+
+    expect(threads).to be_empty
+
+    # put threads back into the queue for killing
+    threads << tmp.pop until tmp.empty?
+  end
+
+  after do
+    StackWaiter.no_longer
+    actor_system.shutdown
+  end
+
+  describe "#actors" do
+    it "should include all actors" do
+      expect(subject.actors.size).to eq(2)
+    end
+  end
+
+  describe "#threads" do
+    # TODO: this spec should use mocks because it's non-deterministict
+    it "should include threads that are not actors" do
+      # TODO: Assess need for bypassing StackWaiter.forever's QUEUE.pop after #670 & #678
+      # NOTE: Pool#each doesn't guarantee to contain the newly started thread
+      # because the actor's methods (which create and store the thread handle)
+      # are started asynchronously.
+      #
+      # The mutexes in InternalPool especially can cause additional delay -
+      # causing Pool#get to wait for IPool#each to free the mutex before the
+      # new thread can be stored.
+      #
+      # And, Internals::StackDump#threads is cached, so we have to reconstruct the
+      # Internals::StackDump until it matches reality.
+      #
+      # Also, the actual number of threads and how InternalPool juggles them is
+      # non deterministic to begin with:
+      #
+      # 2 actors
+      #   -> *0-1 task threads
+      #
+      # *1 idle thread
+      # *1 active thread
+      #
+      # Together: 3-4 threads
+
+      # Pool somehow doesn't create extra tasks
+      # 5 is on JRuby-head
+      expected = Celluloid.group_class == Celluloid::Group::Pool ? [3, 4] : [3, 4, 5, 6]
+      expect(expected).to include(subject.threads.size)
+    end
+
+    it "should include idle threads" do
+      expect(subject.threads.map(&:thread_id)).to include(@idle_thread.object_id)
+    end
+
+    it "should include threads checked out of the group for roles other than :actor" do
+      expect(subject.threads.map(&:thread_id)).to include(@active_thread.object_id)
+    end
+
+    it "should have the correct roles" do
+      expect(subject.threads.map(&:role)).to include(:idle_thing, :other_thing)
+    end
+  end
+end

data/spec/shared/task_examples.rb

@@ -5,8 +5,7 @@ class MockActor
     @tasks = []
   end
 
-  def setup_thread
-  end
+  def setup_thread; end
 end
 
 RSpec.shared_examples "a Celluloid Task" do
@@ -41,7 +40,7 @@ RSpec.shared_examples "a Celluloid Task" do
 
   it "raises exceptions outside" do
     task = Celluloid.task_class.new(task_type, {}) do
-      fail "failure"
+      raise "failure"
     end
     expect do
       task.resume

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
-require "rubygems"
-require "bundler/setup"
-
+require "rspec/retry"
 require "celluloid/rspec"
-require "celluloid/essentials"
+require "celluloid/supervision"
 
 Dir[*Specs::INCLUDE_PATHS].map { |f| require f }

data/spec/support/configure_rspec.rb

@@ -1,5 +1,4 @@
 RSpec.configure do |config|
-  config.filter_run focus: true unless Nenv.ci?
   config.run_all_when_everything_filtered = true
   config.disable_monkey_patching!
   config.profile_examples = 3
@@ -19,7 +18,7 @@ RSpec.configure do |config|
   config.before(:suite) do
     Specs.stub_out_class_method(Celluloid::Internals::Logger, :crash) do |*args|
       _name, ex = *args
-      fail "Unstubbed Logger.crash() was called:\n  crash(\n    #{args.map(&:inspect).join(",\n    ")})"\
+      raise "Unstubbed Logger.crash() was called:\n  crash(\n    #{args.map(&:inspect).join(",\n    ")})"\
         "\nException backtrace: \n  (#{ex.class}) #{ex.backtrace * "\n  (#{ex.class}) "}"
     end
   end
@@ -42,7 +41,7 @@ RSpec.configure do |config|
         "\n** Crash: #{msg.inspect}(#{ex.inspect})\n  Backtrace:\n    (crash) #{call_stack * "\n    (crash) "}"\
           "\n  Exception Backtrace (#{ex.inspect}):\n    (ex) #{ex.backtrace * "\n    (ex) "}"
       end.join("\n")
-      fail "Actor crashes occured (please stub/mock if these are expected): #{crashes}"
+      raise "Actor crashes occurred (please stub/mock if these are expected): #{crashes}"
     end
     @fake_logger = nil
     Specs.assert_no_loose_threads!("after example: #{ex.description}") if Specs::CHECK_LOOSE_THREADS

data/spec/support/coverage.rb

@@ -1,4 +1,2 @@
-if Nenv.ci?
-  require "coveralls"
-  Coveralls.wear!
-end
+require "coveralls"
+Coveralls.wear!

data/spec/support/crash_checking.rb

@@ -19,7 +19,7 @@ module Specs
 
     def crash(*args)
       check
-      fail "Testing block has already ended!" if @details
+      raise "Testing block has already ended!" if @details
       @crashes << [args, caller.dup]
     end
 
@@ -59,7 +59,7 @@ module Specs
     def check
       return if self.class.allowed_logger.first == self
 
-      fail "Incorrect logger used:"\
+      raise "Incorrect logger used:"\
         " active/allowed: \n#{clas.allowed_logger.inspect},\n"\
         " actual/self: \n#{[self, @example].inspect}\n"\
         " (maybe an actor from another test is still running?)"

data/spec/support/examples/actor_class.rb

@@ -45,7 +45,7 @@ module ExampleActorClass
       end
 
       def crash
-        fail ExampleCrash, "the spec purposely crashed me :("
+        raise ExampleCrash, "the spec purposely crashed me :("
       end
 
       def crash_with_abort(reason, foo = nil)
@@ -89,11 +89,7 @@ module ExampleActorClass
       end
 
       def respond_to?(method_name, include_private = false)
-        if delegates?(method_name)
-          delegates?(method_name)
-        else
-          super
-        end
+        delegates?(method_name) || super
       end
 
       def method(method_name)
@@ -114,8 +110,7 @@ module ExampleActorClass
       private :zomg_private
       attr_reader :private_called
 
-      def my_finalizer
-      end
+      def my_finalizer; end
 
       private
 

data/spec/support/examples/call_class.rb

@@ -8,7 +8,7 @@ class CallExampleActor
   def actual_method; end
 
   def inspect
-    fail "Don't call!"
+    raise "Don't call!"
   end
 
   def chained_call_ids
@@ -28,7 +28,7 @@ class DeprecatedCallExampleActor
   def actual_method; end
 
   def inspect
-    fail "Please don't call me! I'm not ready yet!"
+    raise "Please don't call me! I'm not ready yet!"
   end
 
   def chained_call_ids

data/spec/support/examples/container_class.rb

@@ -0,0 +1,35 @@
+class SupervisionContainerHelper
+  @queue = nil
+  class << self
+    def reset!
+      @queue = Queue.new
+    end
+
+    def done!
+      @queue << :done
+    end
+
+    def pop!
+      @queue.pop
+    end
+  end
+end
+
+class MyContainerActor
+  include Celluloid
+
+  attr_reader :args
+
+  def initialize(*args)
+    @args = args
+    ready
+  end
+
+  def running?
+    :yep
+  end
+
+  def ready
+    SupervisionContainerHelper.done!
+  end
+end

data/spec/support/examples/evented_mailbox_class.rb

@@ -17,8 +17,7 @@ class TestEventedMailbox < Celluloid::Mailbox::Evented
       end
     end
 
-    def shutdown
-    end
+    def shutdown; end
   end
 
   def initialize