servolux 0.9.7 → 0.10.0

data/History.txt

@@ -1,3 +1,12 @@
+== 0.10.0 / 2012-02-18
+
+* Minor Enhancements
+  * Add in the ability to vary the Prefork worker pool size [issue #8]
+  * Pass original child exception backtrace up the exception chain [issue #7]
+  * Improved child process wellness checks in Piper and Child classes
+* Bug Fixes
+  * Typo and documentation fixes [issue #6]
+
 == 0.9.7 / 2012-01-19
 
 * Minor Enhancements

data/README.rdoc

@@ -8,7 +8,7 @@ by Tim Pease {<img src="https://secure.travis-ci.org/TwP/servolux.png">}[http://
 
 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
-documented and tested. It works with Ruby and JRuby supporing both 1.8 and 1.9
+documented and tested. It works with Ruby and JRuby supporting both 1.8 and 1.9
 interpreters.
 
 === FEATURES
@@ -29,7 +29,7 @@ process to be passed to the parent and raised there.
 
 Servolux::Daemon -- a robust class for starting and stopping daemon processes.
 
-Servolux::Child -- adds some much needed funtionality to child processes
+Servolux::Child -- adds some much needed functionality to child processes
 created via Ruby's IO#popen method. Specifically, a timeout thread is used to
 signal the child process to die if it does not exit in a given amount of time.
 

data/Rakefile

@@ -14,7 +14,7 @@ Bones {
   email        'tim.pease@gmail.com'
   url          'http://gemcutter.org/gems/servolux'
   readme_file  'README.rdoc'
-  spec.opts << '--color'
+  spec.opts << '--color' << '--format documentation'
 
   use_gmail
 

data/examples/beanstalk.rb

@@ -2,12 +2,12 @@
 #
 # In this example, we prefork 7 processes each of which connect to our
 # Beanstalkd queue and then wait for jobs to process. We are using a module so
-# that we can connect to the beanstalk queue before exectuing and then
+# that we can connect to the beanstalk queue before executing and then
 # disconnect from the beanstalk queue after exiting. These methods are called
 # exactly once per child process.
 #
 # A variation on this is to load source code in the before_executing method
-# and initialize an object that will process jobs. This is advantagous because
+# and initialize an object that will process jobs. This is advantageous because
 # now you can send SIGHUP to a child process and it will restart, loading your
 # Ruby libraries before executing. Now you can do a rolling deploy of new
 # code.

data/examples/preforking_server.rb

@@ -0,0 +1,151 @@
+require 'rubygems'
+require 'servolux'
+require 'logger'
+
+###############################################################################
+# This is an example script that creates uses both Prefork and Server
+#
+# The Server will manage the Prefork pool and respond to signals to add new
+# workers to the pool
+###############################################################################
+
+# The child script that will be executed, this is just a shell script that
+# will be execed by each worker pool member.
+module ExecChild
+  def self.the_script
+    <<__sh__
+#!/bin/sh
+#
+trap "echo I am process $$" SIGUSR1
+trap "exit 0" SIGHUP
+trap "exit 1" SIGTERM
+
+echo "[$$] I am a child program"
+while true
+do
+  sleep 1
+done
+__sh__
+  end
+
+  def self.script_name
+    "/tmp/exec-child-worker.sh"
+  end
+
+  def self.write_script
+    File.open( script_name, "w+", 0750 ) do |f|
+      f.write( the_script )
+    end
+  end
+
+  def self.remove_script
+    File.unlink( script_name )
+  end
+
+  def execute
+    exec ExecChild.script_name
+  end
+end
+
+class PreforkingServerExample < ::Servolux::Server
+
+  # Create a preforking server that has the given minimum and maximum boundaries
+  #
+  def initialize( min_workers = 2, max_workers = 10 )
+    @logger = ::Logger.new( $stderr )
+    super( self.class.name, :interval => 2, :logger => @logger )
+    @pool = Servolux::Prefork.new( :module => ExecChild, :timeout => nil,
+                                   :min_workers => min_workers, :max_workers => max_workers )
+  end
+
+  def log( msg )
+    logger.info msg
+  end
+
+  def log_pool_status
+    log "Pool status : #{@pool.worker_counts.inspect} living pids #{live_worker_pids.join(' ')}"
+  end
+
+  def live_worker_pids
+    pids = []
+    @pool.each_worker { |w| pids << w.pid if w.alive? }
+    return pids
+  end
+
+  def shutdown_workers
+    log "Shutting down all workers"
+    @pool.stop
+    loop do
+      log_pool_status
+      break if @pool.live_worker_count <= 0
+      sleep 0.25
+    end
+  end
+
+  def log_worker_status( worker )
+    if not worker.alive? then
+      worker.wait
+      if worker.exited? then
+        log "Worker #{worker.pid} exited with status #{worker.exitstatus}"
+      elsif worker.signaled? then
+        log "Worker #{worker.pid} signaled by #{worker.termsig}"
+      elsif worker.stopped? then
+        log "Worker #{worker.pid} stopped by #{worker.stopsig}"
+      else
+        log "I have no clue #{worker.inspect}"
+      end
+    end
+  end
+
+
+  #############################################################################
+  # Implementations of parts of the Servolux::Server API
+  #############################################################################
+
+  # this is run once before the Server's run loop
+  def before_starting
+    ExecChild.write_script
+    log "Starting up the Pool"
+    @pool.start( 1 )
+    log "Send a USR1 to add a worker                        (kill -usr1 #{Process.pid})"
+    log "Send a USR2 to kill all the workers                (kill -usr2 #{Process.pid})"
+    log "Send a INT (Ctrl-C) or TERM to shutdown the server (kill -term #{Process.pid})"
+  end
+
+  # Add a worker to the pool when USR1 is received
+  def usr1
+    log "Adding a worker"
+    @pool.add_workers
+  end
+
+  # kill all the current workers with a usr2, the run loop will respawn up to
+  # the min_worker count
+  #
+  def usr2
+    shutdown_workers
+  end
+
+  # By default, Servolux::Server will capture the TERM signal and call its
+  # +shutdown+ method. After that +shutdown+ method is called it will call
+  # +after_shutdown+ we're going to hook into that so that all the workers get
+  # cleanly shutdown before the parent process exits
+  def after_stopping
+    shutdown_workers
+    ExecChild.remove_script
+  end
+
+  # This is the method that is executed during the run loop
+  #
+  def run
+    log_pool_status
+    @pool.each_worker do |worker|
+      log_worker_status( worker )
+    end
+    @pool.ensure_worker_pool_size
+  end
+end
+
+if $0 == __FILE__ then
+  pse = PreforkingServerExample.new
+  pse.startup
+end

data/examples/server_beanstalk.rb

@@ -25,7 +25,7 @@ server.startup
 # pool to be gracefully stopped and to be monitored by the server thread. This
 # monitoring involves reaping child processes that have died and reporting on
 # errors raised by children. It is also possible to respawn dead child
-# workers, but this should be thuroughly thought through (ha, unintentional
+# workers, but this should be thoroughly thought through (ha, unintentional
 # alliteration) before doing so [if the CPU is thrashing, then respawning dead
 # child workers will only contribute to the thrash].
 module BeanstalkWorkerPool
@@ -38,7 +38,7 @@ module BeanstalkWorkerPool
 
   # This run loop will be called at a fixed interval by the server thread. If
   # the pool has any child processes that have died or restarted, then the
-  # expired PIDs are reaed from the proc table. If any workers in the pool
+  # expired PIDs are read from the proc table. If any workers in the pool
   # have reported an error, then display those errors on STDOUT; these are
   # errors raised from the child process that caused the child to terminate.
   def run

data/lib/servolux.rb

@@ -18,7 +18,7 @@ module Servolux
   end
 
   # Returns the library path for the module. If any arguments are given,
-  # they will be joined to the end of the libray path using
+  # they will be joined to the end of the library path using
   # <tt>File.join</tt>.
   #
   # @return [String] absolute servolux 'lib' path

data/lib/servolux/child.rb

@@ -130,6 +130,18 @@ class Servolux::Child
   # global variable $? is set to a Process::Status object containing
   # information on the child process.
   #
+  # You can get more information about how the child status exited by calling
+  # the following methods on the piper instance:
+  #
+  #   * coredump?
+  #   * exited?
+  #   * signaled?
+  #   * stopped?
+  #   * success?
+  #   * exitstatus
+  #   * stopsig
+  #   * termsig
+  #
   # @param [Integer] flags Bit flags that will be passed to the system level
   #   wait call. See the Ruby core documentation for Process#wait for more
   #   information on these flags.
@@ -138,8 +150,7 @@ class Servolux::Child
   #
   def wait( flags = 0 )
     return if @io.nil?
-    Process.wait(@pid, flags)
-    @status = $?
+    _, @status = Process.wait2(@pid, flags) unless @status
     exitstatus
   end
 
@@ -150,6 +161,7 @@ class Servolux::Child
   #
   def alive?
     return if @io.nil?
+    wait(Process::WNOHANG|Process::WUNTRACED)
     Process.kill(0, @pid)
     true
   rescue Errno::ESRCH, Errno::ENOENT

data/lib/servolux/daemon.rb

@@ -112,16 +112,16 @@ class Servolux::Daemon
   #   The time (in seconds) to wait for the daemon process to either startup
   #   or shutdown. An error is raised when this timeout is exceeded.
   #
-  # @option opts [Boolen] :nochdir (false)
+  # @option opts [Boolean] :nochdir (false)
   #   When set to true this flag directs the daemon process to keep the
   #   current working directory. By default, the process of daemonizing will
   #   cause the current working directory to be changed to the root folder
   #   (thus preventing the daemon process from holding onto the directory
   #   inode).
   #
-  # @option opts [Boolen] :noclose (false)
+  # @option opts [Boolean] :noclose (false)
   #   When set to true this flag keeps the standard input/output streams from
-  #   being reopend to /dev/null when the daemon process is created. Reopening
+  #   being reopened to /dev/null when the daemon process is created. Reopening
   #   the standard input/output streams frees the file descriptors which are
   #   still being used by the parent process. This prevents zombie processes.
   #
@@ -131,7 +131,7 @@ class Servolux::Daemon
   #
   # @option opts [String] :log_file (nil)
   #   This log file will be monitored to determine if the daemon process has
-  #   sucessfully started.
+  #   successfully started.
   #
   # @option opts [String, Regexp] :look_for (nil)
   #   This can be either a String or a Regexp. It defines a phrase to search
@@ -186,7 +186,7 @@ class Servolux::Daemon
   #
   # If the startup command is a Proc or a bound Method then it is invoked
   # using the +call+ method on the object. No arguments are passed to the
-  # +call+ invocoation.
+  # +call+ invocation.
   #
   # Lastly, if the startup command is a Servolux::Server then its +startup+
   # method is called.
@@ -392,7 +392,7 @@ private
     started = wait_for {
       rv = started?
       err = @piper.gets
-      raise StartupError, "Child raised error: #{err.inspect}" unless err.nil?
+      raise StartupError, "Child raised error: #{err.inspect}", err.backtrace unless err.nil?
       rv
     }
 

data/lib/servolux/piper.rb

@@ -2,13 +2,13 @@
 require 'socket'
 
 # == Synopsis
-# A Piper is used to fork a child proces and then establish a communication
+# A Piper is used to fork a child process and then establish a communication
 # pipe between the parent and child. This communication pipe is used to pass
 # Ruby objects between the two.
 #
 # == Details
 # When a new piper instance is created, the Ruby process is forked into two
-# porcesses - the parent and the child. Each continues execution from the
+# processes - the parent and the child. Each continues execution from the
 # point of the fork. The piper establishes a pipe for communication between
 # the parent and the child. This communication pipe can be opened as read /
 # write / read-write (from the perspective of the parent).
@@ -124,6 +124,7 @@ class Servolux::Piper
       raise ArgumentError, "Unsupported mode #{mode.inspect}"
     end
 
+    @status = nil
     @timeout = opts.fetch(:timeout, nil)
     socket_pair = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
     @child_pid = Kernel.fork
@@ -207,7 +208,7 @@ class Servolux::Piper
     end
   end
 
-  # Returns +true+ if this is the child prcoess and +false+ otherwise.
+  # Returns +true+ if this is the child process and +false+ otherwise.
   #
   # @return [Boolean]
   #
@@ -235,7 +236,7 @@ class Servolux::Piper
     end
   end
 
-  # Returns +true+ if this is the parent prcoess and +false+ otherwise.
+  # Returns +true+ if this is the parent process and +false+ otherwise.
   #
   # @return [Boolean]
   #
@@ -309,11 +310,43 @@ class Servolux::Piper
   #   the child process.
   #
   def signal( sig )
-    return if @child_pid.nil?
-    sig = Signal.list.invert[sig] if sig.is_a?(Integer)
+    return if child?
+    return unless alive?
     Process.kill(sig, @child_pid)
   end
 
+  # Waits for the child process to exit and returns its exit status. The
+  # global variable $? is set to a Process::Status object containing
+  # information on the child process.
+  #
+  # Always returns +nil+ when called from the child process.
+  #
+  # You can get more information about how the child status exited by calling
+  # the following methods on the piper instance:
+  #
+  #   * coredump?
+  #   * exited?
+  #   * signaled?
+  #   * stopped?
+  #   * success?
+  #   * exitstatus
+  #   * stopsig
+  #   * termsig
+  #
+  # @param [Integer] flags Bit flags that will be passed to the system level
+  #   wait call. See the Ruby core documentation for Process#wait for more
+  #   information on these flags.
+  # @return [Integer, nil] The exit status of the child process or +nil+ if
+  #   the child process is not running.
+  #
+  def wait( flags = 0 )
+    return if child?
+    _, @status = Process.wait2(@child_pid, flags) unless @status
+    exitstatus
+  rescue Errno::ECHILD
+    nil
+  end
+
   # Returns +true+ if the child process is alive. Returns +nil+ if the child
   # process has not been started.
   #
@@ -322,12 +355,22 @@ class Servolux::Piper
   # @return [Boolean, nil]
   #
   def alive?
-    return if @child_pid.nil?
+    return if child?
+    wait(Process::WNOHANG|Process::WUNTRACED)
     Process.kill(0, @child_pid)
     true
   rescue Errno::ESRCH, Errno::ENOENT
     false
   end
 
+  %w[coredump? exited? signaled? stopped? success? exitstatus stopsig termsig].
+  each { |method|
+    self.class_eval <<-CODE
+      def #{method}
+        return if @status.nil?
+        @status.#{method}
+      end
+    CODE
+  }
 end
 

data/lib/servolux/prefork.rb

@@ -127,7 +127,7 @@
 #
 class Servolux::Prefork
 
-  Timeout = Class.new(::Servolux::Error)
+  CommunicationError = Class.new(::Servolux::Error)
   UnknownSignal = Class.new(::Servolux::Error)
   UnknownResponse = Class.new(::Servolux::Error)
 
@@ -138,8 +138,9 @@ class Servolux::Prefork
   HEARTBEAT = "\000<3".freeze    # @private
   # :startdoc:
 
-  attr_accessor :timeout    # Communication timeout in seconds.
-  attr_reader :harvest      # List of child PIDs that need to be reaped
+  attr_accessor :timeout     # Communication timeout in seconds.
+  attr_accessor :min_workers # Minimum number of workers
+  attr_accessor :max_workers # Maximum number of workers
 
   # call-seq:
   #    Prefork.new { block }
@@ -156,15 +157,22 @@ class Servolux::Prefork
   # If you do not want to use the heartbeat then leave the :timeout unset or
   # manually set it to +nil+.
   #
+  # Additionally, :min_workers and :max_workers options are avilable. If
+  # :min_workers is given, the method +ensure_worker_pool_size+ will guarantee
+  # that at least :min_workers are up and running. If :max_workers is given,
+  # then +add_workers+ will NOT allow ou to spawn more workers than
+  # :max_workers.
+  #
   # The pre-forking worker pool makes no effort to restart dead workers. It is
   # left to the user to implement this functionality.
   #
   def initialize( opts = {}, &block )
     @timeout = opts.fetch(:timeout, nil)
     @module = opts.fetch(:module, nil)
+    @max_workers = opts.fetch(:max_workers, nil)
+    @min_workers = opts.fetch(:min_workers, nil)
     @module = Module.new { define_method :execute, &block } if block
     @workers = []
-    @harvest = Queue.new
 
     raise ArgumentError, 'No code was given to execute by the workers.' unless @module
   end
@@ -177,13 +185,8 @@ class Servolux::Prefork
   #
   def start( number )
     @workers.clear
-
-    number.times {
-      @workers << Worker.new(self)
-      @workers.last.extend @module
-    }
-    @workers.each { |worker| worker.start; pause }
-    self
+    add_workers( number )
+   self
   end
 
   # Stop all workers. The current process will wait for each child process to
@@ -204,17 +207,14 @@ class Servolux::Prefork
   # @return [Prefork] self
   #
   def reap
-    while !@harvest.empty?
-      pid = @harvest.pop
-      Process.wait pid rescue nil
-    end
+    @workers.each { |worker| worker.alive? }
     self
   end
 
   # Send this given _signal_ to all child process. The default signal is
   # 'TERM'. The method waits for a short period of time after the signal is
   # sent to each child; this is done to alleviate a flood of signals being
-  # sent simultaneously and overwhemlming the CPU.
+  # sent simultaneously and overwhelming the CPU.
   #
   # @param [String, Integer] signal The signal to send to child processes.
   # @return [Prefork] self
@@ -228,7 +228,7 @@ class Servolux::Prefork
   # call-seq:
   #    each_worker { |worker| block }
   #
-  # Iterates over all the works and yields each, in turn, to the given
+  # Iterates over all the workers and yields each, in turn, to the given
   # _block_.
   #
   def each_worker( &block )
@@ -236,6 +236,70 @@ class Servolux::Prefork
     self
   end
 
+  # call-seq:
+  #    add_workers( number = 1 )
+  #
+  # Adds additional workers to the pool. It will not add more workers than
+  # the number set in :max_workers
+  #
+  def add_workers( number = 1 )
+    number.times do
+      break if at_max_workers?
+      worker = Worker.new( self )
+      worker.extend @module
+      worker.start
+      @workers << worker
+      pause
+    end
+  end
+
+  # call-seq:
+  #    prune_workers()
+  #
+  # Remove workers that are no longer alive from the worker pool
+  #
+  def prune_workers
+    new_workers = @workers.find_all { |w| w.alive? }
+    @workers = new_workers
+  end
+
+  # call-seq:
+  #   ensure_worker_pool_size()
+  #
+  # Make sure that the worker pool has >= the minimum number of workers and less
+  # than the maximum number of workers.
+  #
+  # Generally, this means prune the number of workers and then spawn workers up
+  # to the min_worker level. If min is not set, then we only prune
+  #
+  def ensure_worker_pool_size
+    prune_workers
+    while below_minimum_workers? do
+      add_workers
+    end
+  end
+
+  # call-seq:
+  #   below_minimum_workers?
+  #
+  # Report if the number of workers is below the minimum threshold
+  #
+  def below_minimum_workers?
+    return false unless @min_workers
+    return @workers.size < @min_workers
+  end
+
+  # call-seq:
+  #    at_max_workers?
+  #
+  # Return true or false if we are currently at or above the maximum number of
+  # workers allowed.
+  #
+  def at_max_workers?
+    return false unless @max_workers
+    return @workers.size >= @max_workers
+  end
+
   # call-seq:
   #    errors { |worker| block }
   #
@@ -247,12 +311,40 @@ class Servolux::Prefork
     self
   end
 
+  # call-seq:
+  #    worker_counts -> { :alive => 2, :dead => 1 }
+  #
+  # Returns a hash containing the counts of alive and dead workers
+  def worker_counts
+    counts = { :alive => 0, :dead => 0 }
+    each_worker do |worker|
+      state = worker.alive? ? :alive : :dead
+      counts[state] += 1
+    end
+    return counts
+  end
+
+  # call-seq:
+  #    live_worker_count -> Integer
+  #
+  # Returns the number of live workers in the pool
+  def live_worker_count
+    worker_counts[:alive]
+  end
+
+  # call-seq:
+  #    dead_worker_count -> Integer
+  #
+  # Returns the number of dead workers in the pool
+  def dead_worker_count
+    worker_counts[:dead]
+  end
 
 private
 
   # Pause script execution for a random time interval between 0.1 and 0.4
   # seconds. This method is used to slow down the starting and stopping of
-  # child processes in order to avoiad the "thundering herd" problem.
+  # child processes in order to avoid the "thundering herd" problem.
   # http://en.wikipedia.org/wiki/Thundering_herd_problem
   #
   def pause
@@ -274,7 +366,6 @@ private
     #
     def initialize( prefork )
       @timeout = prefork.timeout
-      @harvest = prefork.harvest
       @thread = nil
       @piper = nil
       @error = nil
@@ -317,7 +408,7 @@ private
     #
     def wait
       return if @piper.nil? or @piper.child?
-      Process.wait(@piper.pid, Process::WNOHANG|Process::WUNTRACED)
+      @piper.wait(Process::WNOHANG|Process::WUNTRACED)
     end
 
     # Send this given _signal_ to the child process. The default signal is
@@ -356,9 +447,19 @@ private
     #
     def timed_out?
       return if @piper.nil? or @piper.child?
-      Timeout === @error
+      CommunicationError === @error
     end
 
+    %w[pid coredump? exited? signaled? stopped? success? exitstatus stopsig termsig].
+    each { |method|
+      self.class_eval <<-CODE
+        def #{method}
+          return if @piper.nil?
+          @piper.#{method}
+        end
+      CODE
+    }
+
   private
 
     def close_parent
@@ -378,7 +479,6 @@ private
         rescue StandardError => err
           @error = err
         ensure
-          @harvest << @piper.pid
           close_parent
           start if START == response and !Thread.current[:stop]
         end
@@ -390,6 +490,7 @@ private
       response = nil
       loop {
         break if Thread.current[:stop]
+        break unless @piper.alive?
         @piper.puts HEARTBEAT
         response = @piper.gets(ERROR)
         break if Thread.current[:stop]
@@ -398,8 +499,8 @@ private
         when HEARTBEAT; next
         when START; break
         when ERROR
-          raise Timeout,
-                "Child did not respond in a timely fashion. Timeout is set to #{@timeout.inspect} seconds."
+          raise CommunicationError,
+                "Unable to read data from Child process. Possible timeout, closing of pipe and/or child death."
         when Exception
           @error = response
           break
@@ -416,7 +517,6 @@ private
     # signals and communication with the parent.
     #
     def child
-      @harvest = nil
 
       # if we get a HUP signal, then tell the parent process to stop this
       # child process and start a new one to replace it
@@ -458,8 +558,8 @@ private
         when HALT
           break
         when ERROR
-          raise Timeout,
-                "Parent did not respond in a timely fashion. Timeout is set to #{@timeout.inspect} seconds."
+          raise CommunicationError,
+                "Unable to read data from Parent process. Possible timeout, closing of pipe and/or parent death."
         else
           raise UnknownSignal,
                 "Child received unknown signal: #{signal.inspect}"

data/lib/servolux/server.rb

@@ -16,7 +16,7 @@ require 'thread'
 # SIGINT and SIGTERM are handled by default. These signals will gracefully
 # shutdown the server by calling the +shutdown+ method (provided by default,
 # too). A few other signals can be handled by defining a few methods on your
-# server instance. For example, SIGINT is hanlded by the +int+ method (an
+# server instance. For example, SIGINT is handled by the +int+ method (an
 # alias for +shutdown+). Likewise, SIGTERM is handled by the +term+ method
 # (another alias for +shutdown+). The following signal methods are
 # recognized by the Server class:
@@ -43,7 +43,7 @@ require 'thread'
 # shutdown: +before_stopping+ and +after_stopping+. The first is called just
 # before the run loop thread is signaled for shutdown. The second is called
 # just after the run loop thread has died; the +after_stopping+ method is
-# guarnteed to NOT be called till after the run loop thread is well and
+# guaranteed to NOT be called till after the run loop thread is well and
 # truly dead.
 #
 # == Usage

data/lib/servolux/threaded.rb

@@ -1,6 +1,6 @@
 
 # == Synopsis
-# The Threaded module is used to peform some activity at a specified
+# The Threaded module is used to perform some activity at a specified
 # interval.
 #
 # == Details
@@ -14,7 +14,7 @@
 # Just before the thread is created the +before_starting+ method will be
 # called (if it is defined by the threaded object). Likewise, after the
 # thread is created the +after_starting+ method will be called (if it is
-# defeined by the threaded object).
+# defined by the threaded object).
 #
 # The threaded object is stopped by calling the +stop+ method. This sets an
 # internal flag and then wakes up the thread. The thread gracefully exits
@@ -22,7 +22,7 @@
 # are defined for stopping as well. Just before the thread is stopped the
 # +before_stopping+ method will be called (if it is defined by the threaded
 # object). Likewise, after the thread has died the +after_stopping+ method
-# will be called (if it is defeined by the threaded object).
+# will be called (if it is defined by the threaded object).
 #
 # Calling the +join+ method on a threaded object will cause the calling
 # thread to wait until the threaded object has stopped. An optional timeout
@@ -35,7 +35,7 @@
 module Servolux::Threaded
 
   # This method will be called by the activity thread at the desired
-  # interval. Implementing classes are exptect to provide this
+  # interval. Implementing classes are expect to provide this
   # functionality.
   #
   def run
@@ -189,7 +189,7 @@ module Servolux::Threaded
     _activity_thread.continue_on_error = (value ? true : false)
   end
 
-  # Returns +true+ if the threded object should continue running even if an
+  # Returns +true+ if the threaded object should continue running even if an
   # error is raised by the run method. The default is to return +false+. The
   # threaded object will stop running when an error is raised.
   #

data/spec/prefork_spec.rb

@@ -9,7 +9,7 @@ if Servolux.fork?
 describe Servolux::Prefork do
 
   def pids
-    workers.map! { |w| w.instance_variable_get(:@piper).pid }
+    workers.map! { |w| w.pid }
   end
 
   def workers
@@ -24,9 +24,11 @@ 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
+  rescue Errno::ESRCH, Errno::ENOENT, Errno::ECHILD
     false
   end
 
@@ -121,6 +123,78 @@ describe Servolux::Prefork do
     pid.should_not == pids.last
   end
 
+  it "starts up a stopped worker" do
+    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork.start 2
+    ary = workers
+    sleep 0.250 until ary.all? { |w| w.alive? }
+    sleep 0.250 until worker_count >= 2
+
+    pid = pids.last
+    ary.last.signal 'TERM'
+
+    @prefork.reap until !alive? pid
+    @prefork.each_worker do |worker|
+      worker.start unless worker.alive?
+    end
+    sleep 0.250 until ary.all? { |w| w.alive? }
+    pid.should_not == pids.last
+  end
+
+  it "adds a new worker to the worker pool" do
+    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork.start 2
+    ary = workers
+    sleep 0.250 until ary.all? { |w| w.alive? }
+    sleep 0.250 until worker_count >= 2
+
+
+    @prefork.add_workers( 2 )
+    sleep 0.250 until worker_count >= 4
+    workers.size.should == 4
+  end
+
+  it "only adds workers up to the max_workers value" do
+    @prefork = Servolux::Prefork.new :module => @worker, :max_workers => 3
+    @prefork.start 2
+    ary = workers
+    sleep 0.250 until ary.all? { |w| w.alive? }
+    sleep 0.250 until worker_count >= 2
+
+    @prefork.add_workers( 2 )
+    sleep 0.250 until worker_count >= 3
+    workers.size.should == 3
+  end
+
+  it "prunes workers that are no longer running" do
+    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork.start 2
+    ary = workers
+    sleep 0.250 until ary.all? { |w| w.alive? }
+    sleep 0.250 until worker_count >= 2
+
+    @prefork.add_workers( 2 )
+    sleep 0.250 until worker_count >= 3
+    workers.size.should be == 4
+
+    workers[0].stop
+    sleep 0.250 while workers[0].alive?
+
+    @prefork.prune_workers
+    workers.size.should be == 3
+  end
+
+  it "ensures that there are minimum number of workers" do
+    @prefork = Servolux::Prefork.new :module => @worker, :min_workers => 3
+    @prefork.start 1
+    ary = workers
+    sleep 0.250 until ary.all? { |w| w.alive? }
+    sleep 0.250 until worker_count >= 1
+
+    @prefork.ensure_worker_pool_size
+    sleep 0.250 until worker_count >= 3
+    workers.size.should be == 3
+  end
 end
 end  # Servolux.fork?
 

data/spec/server_spec.rb

@@ -2,6 +2,12 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe Servolux::Server do
+
+  def wait_until( seconds = 5 )
+    start = Time.now
+    sleep 0.250 until (Time.now - start) > seconds or yield
+  end
+
   base = Class.new(Servolux::Server) do
     def initialize( &block )
       super('Test Server', :logger => Logging.logger['Servolux'], &block)
@@ -23,17 +29,17 @@ describe Servolux::Server do
     test(?e, @server.pid_file).should be_false
 
     t = Thread.new {@server.startup}
-    Thread.pass until @server.running? and t.status == 'sleep'
+    wait_until { @server.running? and t.status == 'sleep' }
     test(?e, @server.pid_file).should be_true
 
     @server.shutdown
-    Thread.pass until t.status == false
+    wait_until { t.status == false }
     test(?e, @server.pid_file).should be_false
   end
 
   it 'generates a PID file with mode rw-r----- by default' do
     t = Thread.new {@server.startup}
-    Thread.pass until @server.running? and t.status == 'sleep'
+    wait_until { @server.running? and t.status == 'sleep' }
     test(?e, @server.pid_file).should be_true
 
     @log_output.readline.chomp.should be == %q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid")
@@ -41,14 +47,14 @@ describe Servolux::Server do
     (File.stat(@server.pid_file).mode & 0777).should be == 0640
 
     @server.shutdown
-    Thread.pass until t.status == false
+    wait_until { t.status == false }
     test(?e, @server.pid_file).should be_false
   end
 
   it 'generates PID file with the specified permissions' do
     @server.pid_file_mode = 0400
     t = Thread.new {@server.startup}
-    Thread.pass until @server.running? and t.status == 'sleep'
+    wait_until { @server.running? and t.status == 'sleep' }
     test(?e, @server.pid_file).should be_true
 
     @log_output.readline.chomp.should be == %q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid")
@@ -56,18 +62,18 @@ describe Servolux::Server do
     (File.stat(@server.pid_file).mode & 0777).should be == 0400
 
     @server.shutdown
-    Thread.pass until t.status == false
+    wait_until { t.status == false }
     test(?e, @server.pid_file).should be_false
   end
 
   it 'shuts down gracefully when signaled' do
     t = Thread.new {@server.startup}
-    Thread.pass until @server.running? and t.status == 'sleep'
-    @server.running?.should be_true
+    wait_until { @server.running? and t.status == 'sleep' }
+    @server.should be_running
 
-    Process.kill('INT', $$)
-    Thread.pass until t.status == false
-    @server.running?.should be_false
+    `kill -SIGINT #{$$}`
+    wait_until { t.status == false }
+    @server.should_not be_running
   end
 
   it 'responds to signals that have defined handlers' do
@@ -78,21 +84,31 @@ describe Servolux::Server do
     end
 
     t = Thread.new {@server.startup}
-    Thread.pass until @server.running? and t.status == 'sleep'
+    wait_until { @server.running? and t.status == 'sleep' }
     @log_output.readline
-
-    Process.kill('USR1', $$)
-    @log_output.readline.strip.should be == 'INFO  Servolux : usr1 was called'
-
-    Process.kill('HUP', $$)
-    @log_output.readline.strip.should be == 'INFO  Servolux : hup was called'
-
-    Process.kill('USR2', $$)
-    @log_output.readline.strip.should be == 'INFO  Servolux : usr2 was called'
-
-    Process.kill('TERM', $$)
-    Thread.pass until t.status == false
-    @server.running?.should be_false
+    @log_output.readline.strip.should be == 'DEBUG  Servolux : Starting'
+
+    line = nil
+    Process.kill 'SIGUSR1', $$
+    wait_until { line = @log_output.readline }
+    line.should_not be_nil
+    line.strip.should be == 'INFO  Servolux : usr1 was called'
+
+    line = nil
+    Process.kill 'SIGHUP', $$
+    wait_until { line = @log_output.readline }
+    line.should_not be_nil
+    line.strip.should be == 'INFO  Servolux : hup was called'
+
+    line = nil
+    Process.kill 'SIGUSR2', $$
+    wait_until { line = @log_output.readline }
+    line.should_not be_nil
+    line.strip.should be == 'INFO  Servolux : usr2 was called'
+
+    Process.kill 'SIGTERM', $$
+    wait_until { t.status == false }
+    @server.should_not be_running
   end
 end
 

data/version.txt

@@ -1 +1 @@
-0.9.7
+0.10.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: servolux
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-19 00:00:00.000000000Z
+date: 2012-02-18 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones-rspec
-  requirement: &2154204220 !ruby/object:Gem::Requirement
+  requirement: &2160654620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,32 +21,32 @@ dependencies:
         version: 2.0.1
   type: :development
   prerelease: false
-  version_requirements: *2154204220
+  version_requirements: *2160654620
 - !ruby/object:Gem::Dependency
   name: bones-git
-  requirement: &2154203600 !ruby/object:Gem::Requirement
+  requirement: &2160654100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.2.4
+        version: 1.2.5
   type: :development
   prerelease: false
-  version_requirements: *2154203600
+  version_requirements: *2160654100
 - !ruby/object:Gem::Dependency
   name: logging
-  requirement: &2154203040 !ruby/object:Gem::Requirement
+  requirement: &2160653660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.6.1
+        version: 1.6.2
   type: :development
   prerelease: false
-  version_requirements: *2154203040
+  version_requirements: *2160653660
 - !ruby/object:Gem::Dependency
   name: bones
-  requirement: &2154202560 !ruby/object:Gem::Requirement
+  requirement: &2160653220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,13 +54,13 @@ dependencies:
         version: 3.7.2
   type: :development
   prerelease: false
-  version_requirements: *2154202560
+  version_requirements: *2160653220
 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
 
-  documented and tested. It works with Ruby and JRuby supporing both 1.8 and 1.9
+  documented and tested. It works with Ruby and JRuby supporting both 1.8 and 1.9
 
   interpreters.'
 email: tim.pease@gmail.com
@@ -77,6 +77,7 @@ files:
 - Rakefile
 - examples/beanstalk.rb
 - examples/echo.rb
+- examples/preforking_server.rb
 - examples/server_beanstalk.rb
 - lib/servolux.rb
 - lib/servolux/child.rb