servolux 0.7.1 → 0.8.0

data/History.txt

@@ -1,3 +1,13 @@
+== 0.8.0 / 2009-11-12
+
+* 2 Major Enhancements
+  * Preforking worker pool
+* 1 Minor Enhancement
+  * Default return value for Piper#gets (useful for detecting timeouts)
+* 2 Bug Fixes
+  * The piper is now using a socket pair for bidirectional communication
+  * The piper now defaults to a blocking mode (nil timeout)
+
 == 0.7.1 / 2009-11-06
 
 * 1 Bug Fix

data/Rakefile

@@ -9,6 +9,7 @@ ensure_in_path 'lib'
 require 'servolux'
 
 task :default => 'spec:specdoc'
+task 'gem:release' => ['spec:run', 'rubyforge:release']
 
 Bones {
   name         'servolux'
@@ -20,11 +21,13 @@ Bones {
   ignore_file  '.gitignore'
 
   spec.opts << '--color'
+  rubyforge.name 'codeforpeople'
 
   use_gmail
   enable_sudo
 
   depend_on  'bones-extras', :development => true
+  depend_on  'bones-git',    :development => true
   depend_on  'logging',      :development => true
   depend_on  'rspec',        :development => true
 }

data/a.rb

@@ -0,0 +1,31 @@
+
+$LOAD_PATH.unshift 'lib'
+
+require 'servolux'
+
+STDOUT.sync = true
+
+
+module DoThis
+  def before_executing
+    @fd = File.open("#$$.txt", 'w')
+  end
+
+  def after_executing
+    @fd.close
+  end
+
+  def execute
+    @fd.puts "Process #$$ @ #{Time.now}"
+    sleep 5
+  end
+end
+
+p = Servolux::Prefork.new :module => DoThis, :timeout => 0.5
+p.start 6
+sleep 10
+p.stop
+
+p.errors { |e|
+  puts e.inspect
+}

data/b.rb

@@ -0,0 +1,17 @@
+
+$LOAD_PATH.unshift 'lib'
+
+require 'servolux'
+STDOUT.sync = true
+
+p = Servolux::Prefork.new {
+  puts "Process #$$ @ #{Time.now}"
+  sleep
+}
+p.start 12
+sleep 30
+p.stop
+
+p.errors { |e|
+  puts e.inspect
+}

data/examples/beanstalk.rb

@@ -0,0 +1,65 @@
+# Preforking Beanstalkd job runner using Servolux.
+#
+# 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
+# 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
+# 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.
+#
+#   def before_executing
+#     Kernel.load '/your/source/code.rb'
+#     @job_runner = Your::Source::Code::JobRunner.new
+#   end
+# --------
+
+require 'servolux'
+require 'beanstalk-client'
+
+module JobProcessor
+  # Open a connection to our beanstalk queue
+  def before_executing
+    @beanstalk = Beanstalk::Pool.new(['localhost:11300'])
+  end
+
+  # Close the connection to our beanstalk queue
+  def after_executing
+    @beanstalk.close
+  end
+
+  # Reserve a job from the beanstalk queue, and processes jobs as we receive
+  # them. We have a timeout set for 2 minutes so that we can send a heartbeat
+  # back to the parent process even if the beanstalk queue is empty.
+  def execute
+    job = @beanstalk.reserve(120)
+    if job
+      # process job here ...
+      job.delete
+    end
+  end
+end
+
+# Create our preforking worker pool. Each worker will run the code found in
+# the JobProcessor module. We set a timeout of 10 minutes. The child process
+# must send a "heartbeat" message to the parent within this timeout period;
+# otherwise, the parent will halt the child process.
+#
+# Our execute code in the JobProcessor takes this into account. It will wakeup
+# every 2 minutes, if no jobs are reserved from the beanstalk queue, and send
+# the heartbeat message.
+#
+# This also means that if any job processed by a worker takes longer than 10
+# minutes to run, that child worker will be killed.
+pool = Servolux::Prefork.new(:timeout => 600, :module => JobProcessor)
+
+# Start up 7 child processes to handle jobs
+pool.start 7
+
+# Stop when SIGINT is received.
+trap('INT') { pool.stop }
+Process.waitall

data/examples/echo.rb

@@ -0,0 +1,52 @@
+# Pre-forking echo server using Servolux
+#
+# Run this code using "ruby echo.rb"
+#
+# You can test the server using NetCat from a separate terminal window.
+#
+#    echo "hello world" | nc localhost 4242
+#
+# This example was stolen from Ryan Tomayko and modified to demonstrate the
+# Servolux gem. The original can be found here:
+#
+# http://tomayko.com/writings/unicorn-is-unix
+# --------
+
+require 'servolux'
+
+# Create a socket, bind it to localhost:4242, and start listening.
+# Runs once in the parent; all forked children inherit the socket's
+# file descriptor.
+acceptor = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+address = Socket.pack_sockaddr_in(4242, '0.0.0.0')
+acceptor.bind(address)
+acceptor.listen(10)
+
+# Close the socket when we exit the parent or any child process. This
+# only closes the file descriptor in the calling process, it does not
+# take the socket out of the listening state (until the last fd is
+# closed).
+#
+# The trap is guaranteed to happen, and guaranteed to happen only
+# once, right before the process exits for any reason (unless
+# it's terminated with a SIGKILL).
+trap('EXIT') { acceptor.close }
+
+# Create the worker pool passing in the code to execute in each child
+# process.
+pool = Servolux::Prefork.new {
+  socket, addr = acceptor.accept
+  socket.write "child #$$ echo> "
+  socket.flush
+  message = socket.gets
+  socket.write message
+  socket.close
+  puts "child #$$ echo'd: '#{message.strip}'"
+}
+
+# Start up 3 child process to handle echo requests on the socket.
+pool.start 3
+
+# Stop the child processes when SIGINT is received.
+trap('INT') { pool.stop }
+Process.waitall

data/lib/servolux/piper.rb

@@ -1,4 +1,6 @@
 
+require 'socket'
+
 # == Synopsis
 # A Piper is used to fork a child proces and then establish a communication
 # pipe between the parent and child. This communication pipe is used to pass
@@ -47,7 +49,7 @@
 class Servolux::Piper
 
   # :stopdoc:
-  SEPERATOR = [0xDEAD, 0xBEEF].pack('n*').freeze
+  SIZEOF_INT = [42].pack('I').size
   # :startdoc:
 
   # call-seq:
@@ -90,12 +92,6 @@ class Servolux::Piper
   # The timeout in seconds to wait for puts / gets commands.
   attr_accessor :timeout
 
-  # The read end of the pipe.
-  attr_reader :read_io
-
-  # The write end of the pipe.
-  attr_reader :write_io
-
   # call-seq:
   #    Piper.new( mode = 'r', opts = {} )
   #
@@ -111,7 +107,10 @@ class Servolux::Piper
   #    rw     read-write    read-write
   #
   # The communication timeout can be provided as an option. This is the
-  # number of seconds to wait for a +puts+ or +gets+ to succeed.
+  # number of seconds to wait for a +puts+ or +gets+ to succeed. This timeout
+  # will default to +nil+ such that calls through the pipe will block forever
+  # until data is available. You can configure the +puts+ and +gets+ to be
+  # non-blocking by setting the timeout to +0+.
   #
   def initialize( *args )
     opts = args.last.is_a?(Hash) ? args.pop : {}
@@ -121,55 +120,42 @@ class Servolux::Piper
       raise ArgumentError, "Unsupported mode #{mode.inspect}"
     end
 
-    @timeout = opts[:timeout] || 0
-    if defined? ::Encoding
-      @read_io, @write_io = IO.pipe('ASCII-8BIT')    # encoding for Ruby 1.9
-    else
-      @read_io, @write_io = IO.pipe
-    end
+    @timeout = opts.key?(:timeout) ? opts[:timeout] : nil
+    socket_pair = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
     @child_pid = Kernel.fork
 
     if child?
+      @socket = socket_pair[1]
+      socket_pair[0].close
+
       case mode
-      when 'r'; close_read
-      when 'w'; close_write
+      when 'r'; @socket.close_read
+      when 'w'; @socket.close_write
       end
     else
+      @socket = socket_pair[0]
+      socket_pair[1].close
+
       case mode
-      when 'r'; close_write
-      when 'w'; close_read
+      when 'r'; @socket.close_write
+      when 'w'; @socket.close_read
       end
     end
   end
 
-  # Close both the read and write ends of the communications pipe. This only
-  # affects the process from which it was called -- the parent or the child.
+  # Close both the communications socket. This only affects the process from
+  # which it was called -- the parent or the child.
   #
   def close
-    @read_io.close rescue nil
-    @write_io.close rescue nil
-  end
-
-  # Close the read end of the communications pipe. This only affects the
-  # process from which it was called -- the parent or the child.
-  #
-  def close_read
-    @read_io.close rescue nil
-  end
-
-  # Close the write end of the communications pipe. This only affects the
-  # process from which it was called -- the parent or the child.
-  #
-  def close_write
-    @write_io.close rescue nil
+    @socket.close rescue nil
   end
 
   # Returns +true+ if the communications pipe is readable from the process
   # and there is data waiting to be read.
   #
   def readable?
-    return false if @read_io.closed?
-    r,w,e = Kernel.select([@read_io], nil, nil, @timeout)
+    return false if @socket.closed?
+    r,w,e = Kernel.select([@socket], nil, nil, @timeout)
     return !(r.nil? or r.empty?)
   end
 
@@ -177,8 +163,8 @@ class Servolux::Piper
   # and the write buffer can accept more data.
   #
   def writeable?
-    return false if @write_io.closed?
-    r,w,e = Kernel.select(nil, [@write_io], nil, @timeout)
+    return false if @socket.closed?
+    r,w,e = Kernel.select(nil, [@socket], nil, @timeout)
     return !(w.nil? or w.empty?)
   end
 
@@ -237,22 +223,27 @@ class Servolux::Piper
     @child_pid
   end
 
-  # Read an object from the communication pipe. Returns +nil+ if the pipe is
-  # closed for reading or if no data is available before the timeout
-  # expires. If data is available then it is un-marshalled and returned as a
-  # Ruby object.
+  # Read an object from the communication pipe. If data is available then it
+  # is un-marshalled and returned as a Ruby object. If the pipe is closed for
+  # reading or if no data is available then the _default_ value is returned.
+  # You can pass in the _default_ value; otherwise it will be +nil+.
   #
   # This method will block until the +timeout+ is reached or data can be
   # read from the pipe.
   #
-  def gets
-    return unless readable?
+  def gets( default = nil )
+    return default unless readable?
 
-    data = @read_io.gets SEPERATOR
-    return if data.nil?
+    data = @socket.read SIZEOF_INT
+    return default if data.nil?
+
+    size = data.unpack('I').first
+    data = @socket.read size
+    return default if data.nil?
 
-    data.chomp! SEPERATOR
     Marshal.load(data) rescue data
+  rescue SystemCallError
+    return default
   end
 
   # Write an object to the communication pipe. Returns +nil+ if the pipe is
@@ -267,16 +258,15 @@ class Servolux::Piper
   def puts( obj )
     return unless writeable?
 
-    bytes = @write_io.write Marshal.dump(obj)
-    @write_io.write SEPERATOR if bytes > 0
-    @write_io.flush
-
-    bytes
+    data = Marshal.dump(obj)
+    @socket.write([data.size].pack('I')) + @socket.write(data)
+  rescue SystemCallError
+    return nil
   end
 
   # Send the given signal to the child process. The signal may be an integer
   # signal number or a POSIX signal name (either with or without a +SIG+
-  # prefix). 
+  # prefix).
   #
   # This method does nothing when called from the child process.
   #
@@ -286,6 +276,18 @@ class Servolux::Piper
     Process.kill(sig, @child_pid)
   end
 
+  # Returns +true+ if the child process is alive. Returns +nil+ if the child
+  # process has not been started.
+  #
+  # Always returns +nil+ when called from the child process.
+  #
+  def alive?
+    return if @child_pid.nil?
+    Process.kill(0, @child_pid)
+    true
+  rescue Errno::ESRCH, Errno::ENOENT
+    false
+  end
+
 end  # class Servolux::Piper
 
-# EOF

data/lib/servolux/prefork.rb

@@ -0,0 +1,351 @@
+
+# == Synopsis
+# The Prefork class provides a pre-forking worker pool for executing tasks in
+# parallel using multiple processes.
+#
+# == Details
+# A pre-forking worker pool is a technique for executing code in parallel in a
+# UNIX environment. Each worker in the pool forks a child process and then
+# executes user supplied code in that child process. The child process can
+# pull jobs from a queue (beanstalkd for example) or listen on a socket for
+# network requests.
+#
+# The code to execute in the child processes is passed as a block to the
+# Prefork initialize method. The child processes executes this code in a loop;
+# that is, your code block should not worry about keeping itself alive. This
+# is handled by the library.
+#
+# If your code raises an exception, it will be captured by the library code
+# and marshalled back to the parent process. This will halt the child process.
+# The Prefork worker pool does not restart dead workers. A method is provided
+# to iterate over workers that have errors, and it is up to the user to handle
+# errors as they please.
+#
+# Instead of passing a block to the initialize method, you can provide a Ruby
+# module that defines an "execute" method. This method will be executed in the
+# child process' run loop. When using a module, you also have the option of
+# defining a "before_executing" method and an "after_executing" method. These
+# methods will be called before the child starts the execute loop and after
+# the execute loop finishes. Each method will be called exactly once. Both
+# methods are optional.
+#
+# Sending a SIGHUP to a child process will cause that child to stop and
+# restart. The child will send a signal to the parent asking to be shutdown.
+# The parent will gracefully halt the child and then start a new child process
+# to replace it.
+#
+# This has the advantage of calling your before/after_executing methods again
+# and reloading any code or resources your worker code will use. The SIGHUP
+# will call Thread#wakeup on the main child process thread; please write your
+# code to respond accordingly to this wakeup call (a thread waiting on a
+# Queue#pop will not return when wakeup is called on the thread).
+#
+# == Examples
+#
+# A pre-forking echo server: http://github.com/TwP/servolux/blob/master/examples/echo.rb
+#
+# Pulling jobs from a beanstalkd work queue: http://github.com/TwP/servolux/blob/master/examples/beanstalk.rb
+#
+# ==== Before / After Executing
+# In this example, we are creating 42 worker processes that will log the
+# process ID and the current time to a file. Each worker will do this every 2
+# seconds. The before/after_executing methods are used to open the file before
+# the run loop starts and to close the file after the run loop completes. The
+# execute method uses the stored file descriptor when logging the message.
+#
+#    module RunMe
+#      def before_executing
+#        @fd = File.open("#{Process.pid}.txt", 'w')
+#      end
+#
+#      def after_executing
+#        @fd.close
+#      end
+#
+#      def execute
+#        @fd.puts "Process #{Process.pid} @ #{Time.now}"
+#        sleep 2
+#      end
+#    end
+#
+#    pool = Servolux::Prefork.new(:module => RunMe)
+#    pool.start 42
+#
+# ==== Heartbeat
+# When a :timeout is supplied to the constructor, a "heartbeat" is setup
+# between the parent and the child worker. Each loop through the child's
+# execute code must return before :timeout seconds have elapsed. If one
+# iteration through the loop takes longer than :timeout seconds, then the
+# parent process will halt the child worker. An error will be raised in the
+# parent process.
+#
+#    pool = Servolux::Prefork.new(:timeout => 2) {
+#      puts "Process #{Process.pid} is running."
+#      sleep(rand * 5)
+#    }
+#    pool.start 42
+#
+# Eventually all 42 child processes will be killed by their parents. The
+# random number generator will eventually cause the child to sleep longer than
+# two seconds.
+#
+# What is happening here is that each time the child processes executes the
+# block of code, the Servolux library code will send a "heartbeat" message to
+# the parent. The parent is using a Kernel#select call on the communications
+# pipe to wait for this message. The timeout is passed to the select call, and
+# this will cause it to return +nil+ -- this is the error condition the
+# heartbeat prevents.
+#
+# Use the heartbeat with caution -- allow margins for timing issues and
+# processor load spikes.
+#
+class Servolux::Prefork
+
+  Timeout = Class.new(::Servolux::Error)
+  UnknownSignal = Class.new(::Servolux::Error)
+  UnknownResponse = Class.new(::Servolux::Error)
+
+  # :stopdoc:
+  START = "\000START".freeze
+  HALT = "\000HALT".freeze
+  ERROR = "\000SHIT".freeze
+  HEARTBEAT = "\000<3".freeze
+  # :startdoc:
+
+  attr_accessor :timeout    # Communication timeout in seconds.
+
+  # call-seq:
+  #    Prefork.new { block }
+  #    Prefork.new( :module => Module )
+  #
+  # Create a new pre-forking worker pool. You must provide a block of code for
+  # the workers to execute in their child processes. This code block can be
+  # passed either as a block to this method or as a module via the :module
+  # option.
+  #
+  # If a :timeout is given, then each worker will setup a "heartbeat" between
+  # the parent process and the child process. If the child does not respond to
+  # the parent within :timeout seconds, then the child process will be halted.
+  # If you do not want to use the heartbeat then leave the :timeout unset or
+  # manually set it to +nil+.
+  #
+  # 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[:timeout]
+    @module = opts[:module]
+    @module = Module.new { define_method :execute, &block } if block
+    @workers = []
+
+    raise ArgumentError, 'No code was given to execute by the workers.' unless @module
+  end
+
+  # Start up the given _number_ of workers. Each worker will create a child
+  # process and run the user supplied code in that child process.
+  #
+  def start( number )
+    @workers.clear
+
+    number.times {
+      @workers << Worker.new(self)
+      @workers.last.extend @module
+    }
+    @workers.each { |worker| worker.start }
+    self
+  end
+
+  # Stop all workers. The current process will wait for each child process to
+  # exit before this method will return. The worker instances are not
+  # destroyed by this method; this means that the +each_worker+ and the
+  # +errors+ methods will still function correctly after stopping the workers.
+  #
+  def stop
+    @workers.each { |worker| worker.stop }
+    @workers.each { |worker| worker.wait }
+    self
+  end
+
+  # call-seq:
+  #    each_worker { |worker| block }
+  #
+  # Iterates over all the works and yields each, in turn, to the given
+  # _block_.
+  #
+  def each_worker( &block )
+    @workers.each(&block)
+    self
+  end
+
+  # call-seq:
+  #    errors { |worker| block }
+  #
+  # Iterates over all the works and yields the worker to the given _block_
+  # only if the worker has an error condition.
+  #
+  def errors
+    @workers.each { |worker| yield worker unless worker.error.nil? }
+    self
+  end
+
+  # The worker encapsulates the forking of the child process and communication
+  # between the parent and the child. Each worker instance is extended with
+  # the block or module supplied to the pre-forking pool that created the
+  # worker.
+  #
+  class Worker
+
+    attr_reader :prefork
+    attr_reader :error
+
+    # Create a new worker that belongs to the _prefork_ pool.
+    #
+    def initialize( prefork )
+      @prefork = prefork
+      @thread = nil
+      @piper = nil
+      @error = nil
+    end
+
+    # Start this worker. A new process will be forked, and the code supplied
+    # by the user to the prefork pool will be executed in the child process.
+    #
+    def start
+      @error = nil
+      @piper = ::Servolux::Piper.new('rw', :timeout => @prefork.timeout)
+      parent if @piper.parent?
+      child if @piper.child?
+      self
+    end
+
+    # Stop this worker. The internal worker thread is stopped and a 'HUP'
+    # signal is sent to the child process. This method will return immediately
+    # without waiting for the child process to exit. Use the +wait+ method
+    # after calling +stop+ if your code needs to know when the child exits.
+    #
+    def stop
+      return if @thread.nil? or @piper.nil? or @piper.child?
+
+      @thread[:stop] = true
+      @thread.wakeup
+      Thread.pass until !@thread.status
+      kill 'HUP'
+      @thread = nil
+      self
+    end
+
+    # Wait for the child process to exit. This method returns immediately when
+    # called from the child process or if the child process has not yet been
+    # forked.
+    #
+    def wait
+      return if @piper.nil? or @piper.child?
+      Process.wait(@piper.pid, Process::WNOHANG|Process::WUNTRACED)
+    end
+
+    # Send this given _signal_ to the child process. The default signal is
+    # 'TERM'. This method will return immediately.
+    #
+    def kill( signal = 'TERM' )
+      return if @piper.nil?
+      @piper.signal signal
+    rescue Errno::ESRCH, Errno::ENOENT
+      return nil
+    end
+
+    # Returns +true+ if the child process is alive. Returns +nil+ if the child
+    # process has not been started.
+    #
+    # Always returns +nil+ when called from the child process.
+    #
+    def alive?
+      return if @piper.nil?
+      @piper.alive?
+    end
+
+
+    private
+
+    # This code should only be executed in the parent process.
+    #
+    def parent
+      @thread = Thread.new {
+        response = nil
+        begin
+          @piper.puts START
+          Thread.current[:stop] = false
+          loop {
+            break if Thread.current[:stop]
+            @piper.puts HEARTBEAT
+            response = @piper.gets(ERROR)
+            break if Thread.current[:stop]
+
+            case response
+            when HEARTBEAT; next
+            when START; break
+            when ERROR
+              raise Timeout,
+                    "Child did not respond in a timely fashion. Timeout is set to #{@prefork.timeout} seconds."
+            when Exception
+              raise response
+            else
+              raise UnknownResponse,
+                    "Child returned unknown response: #{response.inspect}"
+            end
+          }
+        rescue Exception => err
+          @error = err
+        ensure
+          @piper.timeout = 0
+          @piper.puts HALT rescue nil
+          @piper.close
+          self.start if START == response
+        end
+      }
+      Thread.pass until @thread[:stop] == false
+    end
+
+    # This code should only be executed in the child process. It wraps the
+    # user supplied "execute" code in a loop, and takes care of handling
+    # signals and communication with the parent.
+    #
+    def child
+      @thread = Thread.current
+
+      # if we get a HUP signal, then tell the parent process to stop this
+      # child process and start a new one to replace it
+      Signal.trap('HUP') {
+        @piper.puts START rescue nil
+        @thread.wakeup
+      }
+
+      before_executing if self.respond_to? :before_executing
+      :wait until @piper.gets == START
+
+      loop {
+        signal = @piper.gets(ERROR)
+        case signal
+        when HEARTBEAT
+          execute
+          @piper.puts HEARTBEAT
+        when HALT
+          break
+        when ERROR
+          raise Timeout,
+                "Parent did not respond in a timely fashion. Timeout is set to #{@prefork.timeout} seconds."
+        else
+          raise UnknownSignal,
+                "Child received unknown signal: #{signal.inspect}"
+        end
+      }
+      after_executing if self.respond_to? :after_executing
+    rescue Exception => err
+      @piper.puts err rescue nil
+    ensure
+      @piper.close
+      exit!
+    end
+  end  # class Worker
+
+end  # class Servolux::Prefork
+

data/lib/servolux.rb

@@ -2,7 +2,7 @@
 module Servolux
 
   # :stopdoc:
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:
@@ -40,8 +40,7 @@ module Servolux
 
 end  # module Servolux
 
-%w[threaded server piper daemon child].each do |lib|
+%w[threaded server piper daemon child prefork].each do |lib|
   require Servolux.libpath('servolux', lib)
 end
 
-# EOF

data/spec/piper_spec.rb

@@ -11,7 +11,7 @@ describe Servolux::Piper do
 
   after :each do
     next if @piper.nil?
-    @piper.puts :die
+    @piper.puts :die rescue nil
     @piper.close
     @piper = nil
   end
@@ -40,6 +40,7 @@ describe Servolux::Piper do
         end
         @piper.puts obj unless obj.nil?
       }
+      exit!
     }
 
     @piper.parent {
@@ -65,7 +66,7 @@ describe Servolux::Piper do
   end
 
   it 'sends signals from parent to child' do
-    @piper = Servolux::Piper.new :timeout => 2
+    @piper = Servolux::Piper.new 'rw', :timeout => 2
 
     @piper.child {
       Signal.trap('USR2') { @piper.puts "'USR2' was received" rescue nil }
@@ -77,6 +78,7 @@ describe Servolux::Piper do
       Thread.new { sleep 7; exit! }
       @piper.puts :ready
       loop { sleep }
+      exit!
     }
 
     @piper.parent {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: servolux
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors: 
 - Tim Pease
@@ -9,13 +9,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-06 00:00:00 -07:00
+date: 2009-11-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bones-extras
   type: :development
   version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bones-git
+  type: :development
+  version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
@@ -50,7 +60,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.0.0
+        version: 3.0.1
     version: 
 description: |-
   Serv-O-Lux is a collection of Ruby classes that are useful for daemon and
@@ -69,10 +79,15 @@ files:
 - History.txt
 - README.rdoc
 - Rakefile
+- a.rb
+- b.rb
+- examples/beanstalk.rb
+- examples/echo.rb
 - lib/servolux.rb
 - lib/servolux/child.rb
 - lib/servolux/daemon.rb
 - lib/servolux/piper.rb
+- lib/servolux/prefork.rb
 - lib/servolux/server.rb
 - lib/servolux/threaded.rb
 - spec/child_spec.rb
@@ -105,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: servolux
+rubyforge_project: codeforpeople
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3