servolux 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 581567ae92a495cdeb92737c979d52e6bd8cf996
-  data.tar.gz: 0f887e81fc0a8b78e1f340578f2183b460a27ca7
+  metadata.gz: 2e69a68c60d72f0b63d0f72ed875dc7f4521e202
+  data.tar.gz: b172073acb33a563d4050f30674b3123c2d05301
 SHA512:
-  metadata.gz: b67919d827ef8ca1e956918d631bbb2a1ffebcedf3334c4197664c674f340910c0156b6973e476f62c1030069a49332752c7847fab262ee219f633260d971e3f
-  data.tar.gz: 4cb69e76d39fece3215048a9032bfa3904888061dc1676b818500bca238503f0659e67ee583d98efd9286caf2abc30ccf0e27b283c8deccc62b5e1ec5fe3c558
+  metadata.gz: 48c6f53a3ee9f8a5f7055e87bb27bbbf359e3c6a8c16e7969ac8b118a3d87441235e98d1253a7e76bae0a89c92cdd67ab2f107ac3c4df493a0413e48e4aa0678
+  data.tar.gz: 1e91faba8537394ecc2b5f3a856261f33e061b26dda3e4e9b449a24fc946b88da4de5fd3466679f0b4cf768a27c0196e2e4aaa60560f51e64446a1d02305b00d

data/.gitignore

@@ -15,6 +15,7 @@ announcement.txt
 coverage
 doc
 pkg
+tags
 .yardoc
 .rvmrc
 vendor

data/.travis.yml

@@ -1,11 +1,15 @@
 language: ruby
 
+notifications:
+  email: false
+
 before_install: "gem install bones"
 install:        "rake gem:install_dependencies"
 
 script: "rake"
 
 rvm:
-  - 1.9.3
-  - 2.1.5
-  - 2.2.2
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0

data/History.txt

@@ -1,3 +1,27 @@
+== 0.13.0 / 2017-03-18
+
+* Minor Enhancements
+  * Using a "self pipe" for signal handling in the Server
+* Bug Fixes
+  * Test cleanup
+  * Better cleanup of child processes across the board
+
+== 0.12.0 / 2015-06-07
+
+* Minor Enhancements
+  * Adding support for a `PidFile` class [pr #19]
+* Bug Fixes
+
+== 0.11.0 / 2015-05-29
+
+* Minor Enhancements
+  * Fixing server shutdown and signal handling in Ruby 2.0 and up [pr #16]
+  * Improving error handling [pr #17]
+  * Added worker options [pr #18]
+  * Added a `boostrap` script for easier development
+* Bug Fixes
+  * Typo and documentation fixes
+
 == 0.10.0 / 2012-02-18
 
 * Minor Enhancements

data/lib/servolux.rb

@@ -37,6 +37,6 @@ module Servolux
   end
 end
 
-%w[version null_logger threaded pid_file server piper daemon child prefork].each do |lib|
+%w[version threaded child daemon null_logger pid_file piper prefork server].each do |lib|
   require Servolux.libpath('servolux', lib)
 end

data/lib/servolux/child.rb

@@ -149,7 +149,7 @@ class Servolux::Child
   #   the child process is not running.
   #
   def wait( flags = 0 )
-    return if @io.nil?
+    return if @pid.nil?
     _, @status = Process.wait2(@pid, flags) unless @status
     exitstatus
   end
@@ -160,7 +160,7 @@ class Servolux::Child
   # @return [Boolean]
   #
   def alive?
-    return if @io.nil?
+    return if @pid.nil?
     wait(Process::WNOHANG|Process::WUNTRACED)
     Process.kill(0, @pid)
     true

data/lib/servolux/piper.rb

@@ -69,7 +69,9 @@ class Servolux::Piper
     piper.parent {
       pid = piper.gets
       raise ::Servolux::Error, 'Could not get the child PID.' if pid.nil?
-      piper.instance_variable_set(:@child_pid, pid)
+
+      piper.wait                                     # reap the child process
+      piper.instance_variable_set(:@child_pid, pid)  # adopt the grandchild
     }
     piper.child {
       Process.setsid                     # Become session leader.
@@ -358,7 +360,7 @@ class Servolux::Piper
     wait(Process::WNOHANG|Process::WUNTRACED)
     Process.kill(0, @child_pid)
     true
-  rescue Errno::ESRCH, Errno::ENOENT
+  rescue Errno::ESRCH, Errno::ENOENT, Errno::ECHILD
     false
   end
 

data/lib/servolux/prefork.rb

@@ -209,7 +209,7 @@ class Servolux::Prefork
   # @return [Prefork] self
   #
   def reap
-    @workers.each { |worker| worker.alive? }
+    @workers.each { |worker| worker.reap }
     self
   end
 
@@ -261,7 +261,7 @@ class Servolux::Prefork
   # Remove workers that are no longer alive from the worker pool
   #
   def prune_workers
-    new_workers = @workers.find_all { |w| w.alive? }
+    new_workers = @workers.find_all { |w| w.reap.alive? }
     @workers = new_workers
   end
 
@@ -375,6 +375,7 @@ private
       @thread = nil
       @piper = nil
       @error = nil
+      @pid_list = []
     end
 
     # Start this worker. A new process will be forked, and the code supplied
@@ -383,6 +384,7 @@ private
     # @return [Worker] self
     #
     def start
+      @pid_list << @piper.pid if @piper
       @error = nil
       @piper = ::Servolux::Piper.new('rw', :timeout => @timeout)
       @piper.parent? ? parent : child
@@ -414,7 +416,7 @@ private
     #
     def wait
       return if @piper.nil? or @piper.child?
-      @piper.wait(Process::WNOHANG|Process::WUNTRACED)
+      @piper.wait(Process::WUNTRACED)
     end
 
     # Send this given _signal_ to the child process. The default signal is
@@ -444,6 +446,31 @@ private
       @piper.alive?
     end
 
+    # Internal: Attempt to reap any child processes spawned by this worker. If a
+    # child has exited, then we remove it from our PID list.
+    #
+    # @return [Worker] this worker instance.
+    def reap
+      @piper.alive? unless @piper.nil?
+      @pid_list.dup.each do |pid|
+        @pid_list.delete(pid) if reap?(pid)
+      end
+      self
+    end
+
+    # Internal: Check the return status of the given child PID. This will reap
+    # the process from the kernel process table if the child has exited.
+    #
+    # @return [Boolean] true if the PID has exited; false otherwise.
+    def reap?(pid)
+      _, cstatus = Process.wait2(pid, Process::WNOHANG|Process::WUNTRACED)
+      return true if cstatus
+      Process.kill(0, pid)
+      false
+    rescue Errno::ESRCH, Errno::ENOENT, Errno::ECHILD
+      true
+    end
+
     # Returns +true+ if communication with the child process timed out.
     # Returns +nil+ if the child process has not been started.
     #

data/lib/servolux/server.rb

@@ -193,6 +193,7 @@ class Servolux::Server
       wait_for_shutdown if wait
     ensure
       pid_file.delete
+      halt_signal_processing
     end
     return self
   end
@@ -259,21 +260,60 @@ class Servolux::Server
 
   private
 
+  def halt_signal_processing
+    if defined?(@wr) && !@wr.nil? && !@wr.closed?
+      @queue << :halt
+      @wr.write("!")
+      @wr.flush
+    end
+  end
+
   def trap_signals
+    @queue = []
+    @rd, @wr = IO.pipe
+
     SIGNALS.each do |sig|
       method = sig.downcase.to_sym
       if self.respond_to? method
         Signal.trap(sig) do
-          Thread.new do
-            begin
-              self.send(method)
-            rescue StandardError => err
-              logger.error "Exception in signal handler: #{method}"
-              logger.error err
-            end
+          begin
+            @queue << method
+            @wr.write_nonblock("!")
+          rescue StandardError => err
+            logger.error "Exception in signal handler: #{method}"
+            logger.error err
           end
         end
       end
     end
+
+    Thread.new {
+      :run while process_signals
+      @rd.close if !@rd.nil? && !@rd.closed?
+      @wr.close if !@wr.nil? && !@wr.closed?
+      logger.info "Signal processing thread has stopped"
+    }
+  end
+
+  def process_signals
+    IO.select([@rd])
+    @rd.read_nonblock(42)
+
+    while !@queue.empty?
+      method = @queue.shift
+      next if method.nil?
+      return false if method == :halt
+
+      self.send(method)
+    end
+    return true
+  rescue IO::WaitReadable
+    return true
+  rescue IOError, EOFError, Errno::EBADF
+    return false
+  rescue StandardError => err
+    logger.error "Exception in signal handler: #{method}"
+    logger.error err
+    return false
   end
 end

data/lib/servolux/version.rb

@@ -1,5 +1,5 @@
 module Servolux
-  VERSION = "0.12.0".freeze
+  VERSION = "0.13.0".freeze
 
   # Returns the version string for the library.
   def self.version

data/script/bootstrap

@@ -2,7 +2,7 @@
 
 gem list -i bones >/dev/null 2>&1
 rc=$?
-if [[ $rc != 0 ]]; then
+if [ "$rc" != "0" ]; then
   gem install bones
 fi
 

data/spec/prefork_spec.rb

@@ -21,14 +21,17 @@ describe Servolux::Prefork do
   end
 
   def alive?( pid )
-    _, cstatus = Process.wait2( pid, Process::WNOHANG )
-    return false if cstatus
     Process.kill(0, pid)
     true
   rescue Errno::ESRCH, Errno::ENOENT, Errno::ECHILD
     false
   end
 
+  def wait_until( seconds = 5 )
+    start = Time.now
+    sleep 0.250 until ((Time.now - start) > seconds) || yield
+  end
+
   before :all do
     tmp = Tempfile.new 'servolux-prefork'
     @path = tmp.path; tmp.unlink
@@ -65,8 +68,8 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 1
     ary = workers
-    sleep 0.1 until ary.all? { |w| w.alive? }
-    sleep 0.1 until worker_count >= 1
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 1 }
 
     ary = Dir.glob(@glob)
     expect(ary.length).to eq(1)
@@ -77,8 +80,8 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 8
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 8
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 8 }
 
     ary = Dir.glob(@glob)
     expect(ary.length).to eq(8)
@@ -91,14 +94,14 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 3
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 3
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 3 }
 
     ary = Dir.glob(@glob)
     expect(ary.length).to eq(3)
 
     @prefork.stop
-    sleep 0.250 until Dir.glob(@glob).length == 0
+    wait_until { Dir.glob(@glob).length == 0 }
     workers.each { |w| w.wait rescue nil }
 
     rv = workers.all? { |w| !w.alive? }
@@ -109,13 +112,14 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 2
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 2 }
 
     pid = pids.last
     ary.last.signal 'HUP'
-    @prefork.reap until !alive? pid
-    sleep 0.250 until ary.all? { |w| w.alive? }
+    wait_until { !alive? pid }
+    @prefork.reap
+    wait_until { ary.all? { |w| w.alive? } }
 
     expect(pid).not_to eq(pids.last)
   end
@@ -124,17 +128,19 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 2
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 2 }
 
     pid = pids.last
     ary.last.signal 'TERM'
 
-    @prefork.reap until !alive? pid
+    wait_until { !alive? pid }
+    @prefork.reap
+
     @prefork.each_worker do |worker|
       worker.start unless worker.alive?
     end
-    sleep 0.250 until ary.all? { |w| w.alive? }
+    wait_until { ary.all? { |w| w.alive? } }
     expect(pid).not_to eq(pids.last)
   end
 
@@ -142,12 +148,12 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 2
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 2 }
 
 
     @prefork.add_workers( 2 )
-    sleep 0.250 until worker_count >= 4
+    wait_until { worker_count >= 4 }
     expect(workers.size).to eq(4)
   end
 
@@ -155,11 +161,11 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :max_workers => 3, :config => {:path => @path}
     @prefork.start 2
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 2
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 2 }
 
     @prefork.add_workers( 2 )
-    sleep 0.250 until worker_count >= 3
+    wait_until { worker_count >= 3 }
     expect(workers.size).to eq(3)
   end
 
@@ -167,15 +173,15 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 2
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 2 }
 
     @prefork.add_workers( 2 )
-    sleep 0.250 until worker_count >= 3
+    wait_until { worker_count >= 3 }
     expect(workers.size).to eq(4)
 
     workers[0].stop
-    sleep 0.250 while workers[0].alive?
+    wait_until { !workers[0].alive? }
 
     @prefork.prune_workers
     expect(workers.size).to eq(3)
@@ -185,11 +191,11 @@ describe Servolux::Prefork do
     @prefork = Servolux::Prefork.new :module => @worker, :min_workers => 3, :config => {:path => @path}
     @prefork.start 1
     ary = workers
-    sleep 0.250 until ary.all? { |w| w.alive? }
-    sleep 0.250 until worker_count >= 1
+    wait_until { ary.all? { |w| w.alive? } }
+    wait_until { worker_count >= 1 }
 
     @prefork.ensure_worker_pool_size
-    sleep 0.250 until worker_count >= 3
+    wait_until { worker_count >= 3 }
     expect(workers.size).to eq(3)
   end
 end

data/spec/server_spec.rb

@@ -5,7 +5,11 @@ describe Servolux::Server do
 
   def wait_until( seconds = 5 )
     start = Time.now
-    sleep 0.250 until (Time.now - start) > seconds or yield
+    sleep 0.250 until ((Time.now - start) > seconds) || yield
+  end
+
+  def readlog
+    @log_output.readline
   end
 
   base = Class.new(Servolux::Server) do
@@ -23,62 +27,63 @@ describe Servolux::Server do
   after :each do
     @server.shutdown
     @server.wait_for_shutdown
+    wait_until { @t.status == false } if @t && @t.alive?
   end
 
   it 'generates a PID file' do
     expect(@server.pid_file).to_not exist
 
-    t = Thread.new {@server.startup}
-    wait_until { @server.running? and t.status == 'sleep' }
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
     expect(@server.pid_file).to exist
 
     @server.shutdown
-    wait_until { t.status == false }
+    wait_until { @t.status == false }
     expect(@server.pid_file).to_not exist
   end
 
   it 'generates a PID file with mode rw-r----- by default' do
-    t = Thread.new {@server.startup}
-    wait_until { @server.running? and t.status == 'sleep' }
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
     expect(@server.pid_file).to exist
 
-    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Writing pid file "./test_server.pid"))
-    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Starting))
+    expect(readlog.chomp).to eq(%q(DEBUG  Servolux : Writing pid file "./test_server.pid"))
+    expect(readlog.chomp).to eq(%q(DEBUG  Servolux : Starting))
 
     filename = @server.pid_file.filename
     mode = File.stat(filename).mode & 0777
     expect(mode).to eq(0640)
 
     @server.shutdown
-    wait_until { t.status == false }
+    wait_until { @t.status == false }
     expect(@server.pid_file).to_not exist
   end
 
   it 'generates PID file with the specified permissions' do
     @server.pid_file.mode = 0400
-    t = Thread.new {@server.startup}
-    wait_until { @server.running? and t.status == 'sleep' }
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
     expect(@server.pid_file).to exist
 
-    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Writing pid file "./test_server.pid"))
-    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Starting))
+    expect(readlog.chomp).to eq(%q(DEBUG  Servolux : Writing pid file "./test_server.pid"))
+    expect(readlog.chomp).to eq(%q(DEBUG  Servolux : Starting))
 
     filename = @server.pid_file.filename
     mode = File.stat(filename).mode & 0777
     expect(mode).to eq(0400)
 
     @server.shutdown
-    wait_until { t.status == false }
+    wait_until { @t.status == false }
     expect(@server.pid_file).to_not exist
   end
 
   it 'shuts down gracefully when signaled' do
-    t = Thread.new {@server.startup}
-    wait_until { @server.running? and t.status == 'sleep' }
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
     expect(@server).to be_running
 
-    `kill -SIGINT #{$$}`
-    wait_until { t.status == false }
+    Process.kill 'SIGINT', $$
+    wait_until { @t.status == false }
     expect(@server).to_not be_running
   end
 
@@ -89,31 +94,31 @@ describe Servolux::Server do
       def usr2() logger.info 'usr2 was called'; end
     end
 
-    t = Thread.new {@server.startup}
-    wait_until { @server.running? and t.status == 'sleep' }
-    @log_output.readline
-    expect(@log_output.readline.strip).to eq('DEBUG  Servolux : Starting')
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
+    readlog
+    expect(readlog.strip).to eq('DEBUG  Servolux : Starting')
 
     line = nil
     Process.kill 'SIGUSR1', $$
-    wait_until { line = @log_output.readline }
+    wait_until { line = readlog }
     expect(line).to_not be_nil
     expect(line.strip).to eq('INFO  Servolux : usr1 was called')
 
     line = nil
     Process.kill 'SIGHUP', $$
-    wait_until { line = @log_output.readline }
+    wait_until { line = readlog }
     expect(line).to_not be_nil
     expect(line.strip).to eq('INFO  Servolux : hup was called')
 
     line = nil
     Process.kill 'SIGUSR2', $$
-    wait_until { line = @log_output.readline }
+    wait_until { line = readlog }
     expect(line).to_not be_nil
     expect(line.strip).to eq('INFO  Servolux : usr2 was called')
 
     Process.kill 'SIGTERM', $$
-    wait_until { t.status == false }
+    wait_until { @t.status == false }
     expect(@server).to_not be_running
   end
 
@@ -122,20 +127,44 @@ describe Servolux::Server do
       def usr2() raise 'Ooops!'; end
     end
 
-    t = Thread.new {@server.startup}
-    wait_until { @server.running? and t.status == 'sleep' }
-    @log_output.readline
-    expect(@log_output.readline.strip).to eq('DEBUG  Servolux : Starting')
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
+    readlog
+    expect(readlog.strip).to eq('DEBUG  Servolux : Starting')
 
     line = nil
     Process.kill 'SIGUSR2', $$
-    wait_until { line = @log_output.readline }
+    wait_until { line = readlog }
     expect(line).to_not be_nil
     expect(line.strip).to eq('ERROR  Servolux : Exception in signal handler: usr2')
 
     line = nil
-    wait_until { line = @log_output.readline }
+    wait_until { line = readlog }
     expect(line).to_not be_nil
     expect(line.strip).to eq('ERROR  Servolux : <RuntimeError> Ooops!')
   end
+
+  it 'logs when the signal handler thread exits' do
+    class << @server
+      def hup() logger.info 'hup was called'; end
+    end
+
+    @t = Thread.new {@server.startup}
+    wait_until { @server.running? and @t.status == 'sleep' }
+    readlog
+    expect(readlog.strip).to eq('DEBUG  Servolux : Starting')
+
+    line = nil
+    @server.__send__(:halt_signal_processing)
+    wait_until { line = readlog }
+    expect(line).to_not be_nil
+    expect(line.strip).to eq('INFO  Servolux : Signal processing thread has stopped')
+
+    line = nil
+    Process.kill 'SIGHUP', $$
+    wait_until { line = readlog }
+    expect(line).to_not be_nil
+    expect(line.strip).to    eq('ERROR  Servolux : Exception in signal handler: hup')
+    expect(readlog.strip).to eq('ERROR  Servolux : <IOError> closed stream')
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servolux
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Tim Pease
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-08 00:00:00.000000000 Z
+date: 2017-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones-rspec
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.3
+        version: 3.8.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.3
+        version: 3.8.4
 description: |-
   Serv-O-Lux is a collection of Ruby classes that are useful for daemon and
   process management, and for writing your own Ruby services. The code is well
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: servolux
-rubygems_version: 2.2.3
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: A collection of tools for working with processes