angael 0.0.2 → 0.0.3

data/angael.gemspec

@@ -20,5 +20,5 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency('rspec', '2.6.0')
-  s.add_development_dependency('rspec-process-mocks')
+  s.add_development_dependency('rspec-process-mocks', '0.0.2')
 end

data/lib/angael/manager.rb

@@ -43,6 +43,20 @@ module Angael
     def start!
       workers.each { |w| w.start! }
 
+      trap("CHLD") do
+        workers.each do |w|
+          result = wait(w.pid)
+#print w.pid.to_s
+#print "\t"
+#p result
+          if result
+            # worker terminated
+            # Restart it unless we asked it to stop.
+            w.restart! unless w.stopping?
+          end
+        end
+      end
+
       loop do
         trap("INT") do
           stop!
@@ -74,5 +88,19 @@ module Angael
       @logger.add(@log_level, "#{Time.now.utc} - #{self.class} (pid #{$$}): #{msg}") if @logger
     end
 
+    # Returns immediately. If the process is still running, it returns nil.
+    # If the process is a zombie, it returns an array with the pid as the
+    # first element and a Process::Status object as the 2nd element, i.e.
+    # it returns the same thing as Process.wait2. If the process does not
+    # exist (i.e. it is completely gone) then it returns an array with the
+    # pid as the first element and nil as the 2nd element (because there
+    # is no Process::Status object to return).
+    def wait(pid)
+      begin
+        Process.wait2(pid, Process::WNOHANG)
+      rescue Errno::ECHILD
+        [pid, nil] # It did exit, but we don't know the exit status.
+      end
+    end
   end
 end

data/lib/angael/version.rb

@@ -1,3 +1,3 @@
 module Angael
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/angael/worker.rb

@@ -24,17 +24,7 @@ module Angael
     # Loops forever, taking jobs off the queue. SIGINT will stop it after
     # allowing any jobs already taken from the queue to be processed.
     def start!
-      trap("CHLD") do
-        __log("trapped SIGCHLD. Child PID #{pid}.")
-
-        # @stopping is set by #stop!. If it is true, then the child process was
-        # expected to die. If it is false/nil, then this is unexpected.
-        __log("Child process died unexpectedly") unless @stopping
-        # Reap the child process so that #started? will return false. But we can't
-        # block because this may be called for a Worker when a different Worker's
-        # child is the process that died.
-        wait_for_child(:dont_block => true) if pid
-      end
+      @stopping = false
 
       @pid = fork_child do
         __log("Started")
@@ -71,8 +61,8 @@ module Angael
         return false
       end
 
-      # Some internal state so that other parts of our code know that we
-      # intentionally stopped the child process.
+      # This informs the Manager (through #stopping?) that we intentionally
+      # stopped the child process.
       @stopping = true
 
       begin
@@ -98,7 +88,6 @@ module Angael
           end
         end
       end
-      @stopping = false
     end
 
     def started?
@@ -107,6 +96,10 @@ module Angael
     def stopped?
       !started?
     end
+    # TODO: test this
+    def stopping?
+      @stopping
+    end
 
     #########
     private #

data/spec/lib/angael/manager_spec.rb

@@ -20,7 +20,8 @@ describe Angael::Manager do
   end
 
   describe "#start!" do
-    subject { Angael::Manager.new(Angael::TestSupport::SampleWorker, 2) }
+    subject { Angael::Manager.new(Angael::TestSupport::SampleWorker, 3) }
+
     it "should start all its workers" do
       subject.workers.each do |w|
         w.should_receive_in_child_process(:start!)
@@ -38,6 +39,87 @@ describe Angael::Manager do
       Process.wait(pid)
     end
 
+    context "when it receives a SIGCHLD" do
+      after(:each) do
+        # Clean up
+        unless Process.wait2(@pid, Process::WNOHANG)
+          Process.kill('KILL', @pid) unless
+          Process.wait(@pid) rescue nil
+        end
+      end
+
+      context "when worker was asked to stop" do
+        it "should not restart the child process" do
+          subject.workers.each do |w|
+            w.stub(:work).and_return { sleep 0.1 }
+            w.should_receive_in_child_process(:restart!).exactly(0).times
+          end
+
+          @pid = Process.fork do
+            subject.start!
+          end
+
+          sleep 0.1 # Give the process a chance to start.
+          # This sends stop! to all the workers.
+          Process.kill('INT', @pid)
+          sleep 0.1 # Give the TempFile a chance to flush
+        end
+
+        it "should reap the child processes" do
+          subject.workers.each do |w|
+            w.stub(:work).and_return { sleep 0.05 }
+          end
+
+          # We need access to the worker objects to get their PIDs, so we
+          # fork a process which will send SIGINT to this current process.
+          # Then we start the Manager in this process and wait for it to
+          # get the SIGINT. Finally we rescue SystemExit so that this
+          # process doesn't exit with the Manager stops.
+          current_pid = $$
+          @pid = Process.fork do
+            sleep 0.1 # Give the process a chance to start.
+            Process.kill('INT', current_pid)
+            exit 0
+          end
+          begin
+            subject.start!
+          rescue SystemExit
+            nil
+          end
+
+          subject.workers.each do |w|
+            lambda do
+              Process.kill(0, w.pid)
+            end.should raise_error(Errno::ESRCH, "No such process")
+          end
+        end
+      end
+
+      context "when worker was not asked to stop" do
+        after(:each) do
+          # Clean up
+          Process.kill('INT', @pid)
+          sleep 0.1
+        end
+        it "should restart the child process" do
+          subject.workers.each do |w|
+            w.stub(:work).and_return do
+              sleep 0.05
+              # This is like exiting with an exception, but it prevents the ugly
+              # stacktrace.
+              exit 1
+            end
+            w.should_receive_in_child_process(:restart!).at_least(1).times
+          end
+
+          @pid = Process.fork do
+            subject.start!
+          end
+
+          sleep 0.1 # Give the process a chance to start.
+        end
+      end
+    end
 
     %w(INT TERM).each do |sig|
       context "when it receives a SIG#{sig}" do

data/spec/lib/angael/worker_spec.rb

@@ -26,6 +26,11 @@ describe Angael::Worker do
       subject.should be_started
     end
 
+    it "should not be stopping" do
+      subject.start!
+      subject.should_not be_stopping
+    end
+
     it "should be doing work" do
       # TODO: Update #should_receive_in_child_process to allow for a
       #       #more_than_once option, then use that instead of setting this all
@@ -63,6 +68,9 @@ describe Angael::Worker do
       it "should not be started" do
         Process.kill('KILL', subject.pid)
         sleep 0.1 # Wait for SIGKILL to take effect.
+        # We must clean up the zombies here because the Worker class noramlly
+        # relies on the worker manager to do that.
+        Process.wait2(subject.pid, Process::WNOHANG)
         subject.should_not be_started
       end
 
@@ -81,26 +89,37 @@ describe Angael::Worker do
     before { subject.stub(:work => nil) }
     after { subject.stop! }
 
-    context "is stopped" do
+    context "when stopped" do
       it "should return false" do
         subject.should_not be_started
         subject.stop!.should be_false
       end
 
+      it "should not be stopping" do
+        subject.stop!
+        subject.should_not be_stopping
+      end
+
       it "should not send a SIGINT to the child process" do
         should_not_receive_and_run(Process, :kill, 'INT', subject.pid)
         subject.stop!
       end
     end
 
-    context "is started" do
+    context "when started" do
       it "should send a SIGINT to the child process" do
         subject.start!
         should_receive_and_run(Process, :kill, 'INT', subject.pid)
         subject.stop!
       end
 
-      context "child process does die within the worker's timeout" do
+      it "should be stopping" do
+        subject.start!
+        subject.stop!
+        subject.should be_stopping
+      end
+
+      context "when child process does die within the worker's timeout" do
         subject do
           worker = Angael::TestSupport::SampleWorker.new
           worker.stub(:timeout => 2)
@@ -132,7 +151,7 @@ describe Angael::Worker do
         end
       end
 
-      context "child process does not die within the worker's timeout" do
+      context "when child process does not die within the worker's timeout" do
         subject do
           worker = Angael::TestSupport::SampleWorker.new
           worker.stub(:timeout => 1)
@@ -176,6 +195,9 @@ describe Angael::Worker do
             # Clean up
             Process._original_kill('KILL', subject.pid)
             sleep 0.1 # Wait for SIGKILL to take effect.
+            # We must clean up the zombies here because the Worker class noramlly
+            # relies on the worker manager to do that.
+            Process.wait2(subject.pid, Process::WNOHANG)
             pid_running?(subject.pid).should be_false
           end
 
@@ -216,31 +238,6 @@ describe Angael::Worker do
             pid, status = Process.wait2(subject.pid)
             status.should == 0
           end
-
-          it "should reap the child process" do
-            # As a general rule, I would only expect this method to be called
-            # once. However, signal behavior is difficult to predict. In some
-            # of our test runs, it is called more than once. If we do receive
-            # multiple SIGCHLD signals (which would be what causes this method
-            # to be called multiple times) there are no ill side effects. Thus
-            # I think it is quite safe to allow this method to be called more
-            # than once.
-            #   -- Paul Cortens (2011-05-18)
-            subject.should_receive(:wait_for_child).at_least(:once)
-
-            subject.start!
-            sleep 0.1 # Make sure there was enough time for the child process to start.
-            Process.kill(sig, subject.pid)
-
-            # We need to wait this long to make sure the child process had time
-            # to respond to the signal. If this is decreased to 'sleep 0.1' then
-            # the tests will sometimes fail because there wasn't enough time for
-            # the trap block to run #wait_for_child.
-            sleep 0.5
-
-            # Clean up zombie child processes.
-            Process.wait(subject.pid)
-          end
         end
       end
     end

data/spec/support/io_helpers.rb

@@ -0,0 +1,14 @@
+module IOHelpers
+  def suppress_stderr
+    # The output stream must be an IO-like object. In this case we capture it in
+    # an in-memory IO object so we can return the string value. You can assign any
+    # IO object here.
+    previous_stderr, $stderr = $stderr, StringIO.new
+    yield
+  ensure
+    # Restore the previous value of stderr (typically equal to STDERR).
+    $stderr = previous_stderr
+  end
+end
+
+RSpec.configuration.include(IOHelpers)

metadata

@@ -2,7 +2,7 @@
 name: angael
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Paul Cortens
@@ -30,9 +30,9 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.0.2
   type: :development
   version_requirements: *id002
 description: Angael is a lightweight library for running repetitive background processes. It handles the forking and signal catching, allow you to just define what the background workers should do.
@@ -56,6 +56,7 @@ files:
 - spec/lib/angael/manager_spec.rb
 - spec/lib/angael/worker_spec.rb
 - spec/spec_helper.rb
+- spec/support/io_helpers.rb
 - spec/support/test_worker.rb
 has_rdoc: true
 homepage: http://github.com/thoughtless/angael