servolux 0.2.0 → 0.4.0

data/History.txt

@@ -1,8 +1,21 @@
+== 0.4.0 / 2009-07-01
+
+* 1 Minor Enhancement
+  * Added a "Child" class for working with child processes
+* 1 Bug Fix
+  * Thread#join has a small bug in JRuby - implemented workaround
+
+== 0.3.0 / 2009-06-24
+
+* 2 Minor Enhancements
+  * Documentation
+  * Unit tests
+
 == 0.2.0 / 2009-06-19
 
 * 1 Minor Enhancement
   * Added a signal method to the Piper class for signaling the child
-* 1 bug fix
+* 1 Bug Fix
   * Fixed a race condition in the Threaded#stop method
 
 == 0.1.0 / 2009-06-18

data/README.rdoc

@@ -1,22 +1,17 @@
 = Serv-O-Lux
 * by Tim Pease
-* http://codeforpeople.rubyforge.org/servolux
+* http://github.com/TwP/servolux/tree/master
 
 === DESCRIPTION:
 
-Threads : Servers : Forks : Daemons
+Threads : Servers : Forks : Daemons : Serv-O-Lux has them all!
 
-=== FEATURES/PROBLEMS:
+=== FEATURES:
 
-* FIXME (list of features or problems)
+http://codeforpeople.rubyforge.org/servolux
 
 === SYNOPSIS:
 
-  FIXME (code sample of usage)
-
-=== REQUIREMENTS:
-
-* FIXME (list of requirements)
 
 === INSTALL:
 

data/lib/servolux.rb

@@ -4,7 +4,7 @@ require 'logging'
 module Servolux
 
   # :stopdoc:
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:
@@ -42,7 +42,7 @@ module Servolux
 
 end  # module Servolux
 
-%w[threaded server piper daemon].each do |lib|
+%w[threaded server piper daemon child].each do |lib|
   require Servolux.libpath('servolux', lib)
 end
 

data/lib/servolux/child.rb

@@ -0,0 +1,116 @@
+
+#
+#
+class Servolux::Child
+
+  attr_accessor :command
+  attr_accessor :timeout
+  attr_accessor :signals
+  attr_accessor :suspend
+  attr_reader :io
+  attr_reader :pid
+
+  #
+  #
+  def initialize( command, opts = {} )
+    @command = command
+    @timeout = opts.getopt :timeout
+    @signals = opts.getopt :signals, %w[TERM QUIT KILL]
+    @suspend = opts.getopt :suspend, 4
+    @io = @pid = @thread = @timed_out = nil
+  end
+
+  #
+  #
+  def start( mode = 'r', &block )
+    start_timeout_thread if @timeout
+
+    @io  = IO::popen @command, mode
+    @pid = @io.pid
+
+    return block.call(@io) unless block.nil?
+    self
+  end
+
+  #
+  #
+  def stop
+    unless @thread.nil?
+      t, @thread = @thread, nil
+      t[:stop] = true
+      t.wakeup.join if t.status
+    end
+
+    kill if alive?
+    @io.close rescue nil
+    @io = @pid = nil
+    self
+  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.
+  #
+  def wait( flags = 0 )
+    return if @io.nil?
+    Process.wait(@pid, flags)
+    $?.exitstatus
+  end
+
+  # Returns +true+ if the child process is alive.
+  #
+  def alive?
+    return if @io.nil?
+    Process.kill(0, @pid)
+    true
+  rescue Errno::ESRCH, Errno::ENOENT
+    false
+  end
+
+  # Returns +true+ if the child process was killed by the timeout thread.
+  #
+  def timed_out?
+    @timed_out
+  end
+
+
+  private
+
+  #
+  #
+  def kill
+    return if @io.nil?
+
+    existed = false
+    @signals.each do |sig|
+      begin
+        Process.kill sig, @pid
+        existed = true
+      rescue Errno::ESRCH, Errno::ENOENT
+        return(existed ? nil : true)
+      end
+      return true unless alive?
+      sleep @suspend
+      return true unless alive?
+    end
+    return !alive?
+  end
+
+  #
+  #
+  def start_timeout_thread
+    @timed_out = false
+    @thread = Thread.new(self) { |child|
+      sleep @timeout
+      unless Thread.current[:stop]
+        if child.alive?
+          child.instance_variable_set(:@timed_out, true)
+          child.__send__(:kill)
+        end
+      end
+    }
+  end
+
+end  # class Servolux::Child
+
+# EOF

data/lib/servolux/daemon.rb

@@ -1,13 +1,77 @@
-
 # == Synopsis
 # The Daemon takes care of the work of creating and managing daemon
-# processes from with Ruby.
+# processes from Ruby.
+#
+# == Details
+# A daemon process is a long running process on a UNIX system that is
+# detached from a TTY -- i.e. it is not tied to a user session. These types
+# of processes are notoriously difficult to setup correctly. This Daemon
+# class encapsulates some best practices to ensure daemons startup properly
+# and can be shutdown gracefully.
+#
+# Starting a daemon process involves forking a child process, setting the
+# child as a session leader, forking again, and detaching from the current
+# working directory and standard in/out/error file descriptors. Because of
+# this separation between the parent process and the daemon process, it is
+# difficult to know if the daemon started properly.
+#
+# The Daemon class opens a pipe between the parent and the daemon. The PID
+# of the daemon is sent to the parent through this pipe. The PID is used to
+# check if the daemon is alive. Along with the PID, any errors from the
+# daemon process are marshalled through the pipe back to the parent. These
+# errors are wrapped in a StartupError and then raised in the parent.
+#
+# If no errors are passed up the pipe, the parent process waits till the
+# daemon starts. This is determined by sending a signal to the daemon
+# process.
+#
+# If a log file is given to the Daemon instance, then it is monitored for a
+# change in size and mtime. This lets the Daemon instance know that the
+# daemon process is updating the log file. Furthermore, the log file can be
+# watched for a specific pattern; this pattern signals that the daemon
+# process is up and running.
+#
+# Shutting down the daemon process is a little simpler. An external shutdown
+# command can be used, or the Daemon instance will send an INT or TERM
+# signal to the daemon process.
+#
+# Again, the Daemon instance will wait till the daemon process shuts down.
+# This is determined by attempting to signal the daemon process PID and then
+# returning when this signal fails -- i.e. then the deamon process has died.
+#
+# == Examples
+#
+# ==== Bad Example
+# This is a bad example. The daemon will not start because the startup
+# command "/usr/bin/no-command-by-this-name" cannot be found on the file
+# system. The daemon process will send an Errno::ENOENT through the pipe
+# back to the parent which gets wrapped in a StartupError
+#
+#    daemon = Servolux::Daemon.new(
+#        :name => 'Bad Example',
+#        :pid_file => '/dev/null',
+#        :startup_command => '/usr/bin/no-command-by-this-name'
+#    )
+#    daemon.startup    #=> raises StartupError
+#
+# ==== Good Example
+# This is a simple Ruby server that prints the time to a file every minute.
+# So, it's not really a "good" example, but it will work.
+#
+#    server = Servolux::Server.new('TimeStamp', :interval => 60)
+#    class << server
+#      def file() @fd ||= File.open('timestamps.txt', 'w'); end
+#      def run() file.puts Time.now; end
+#    end
+#
+#    daemon = Servolux::Daemon.new(:server => server, :log_file => 'timestamps.txt')
+#    daemon.startup
 #
 class Servolux::Daemon
 
-  Error          = Class.new(StandardError)
-  Timeout        = Class.new(Error)
-  AlreadyStarted = Class.new(Error)
+  Error = Class.new(::Servolux::Error)
+  Timeout = Class.new(Error)
+  StartupError = Class.new(Error)
 
   attr_reader   :name
   attr_writer   :logger
@@ -63,7 +127,9 @@ class Servolux::Daemon
   #     prevents zombie processes. The default is false.
   #
   # * shutdown_command
-  #     TODO: Not Yet Implemented
+  #     Assign the startup command. This can be either a String, an Array of
+  #     strings, a Proc, a bound Method, or a Servolux::Server instance.
+  #     Different calling semantics are used for each type of command.
   #
   # * log_file <String>
   #     This log file will be monitored to determine if the daemon process
@@ -155,14 +221,38 @@ class Servolux::Daemon
   #
   def startup
     raise Error, "Fork is not supported in this Ruby environment." unless ::Servolux.fork?
+    return if alive?
+
+    logger.debug "About to fork ..."
+    @piper = ::Servolux::Piper.daemon(nochdir, noclose)
 
-    if alive?
-      raise AlreadyStarted,
-            "#{name.inspect} is already running: " \
-            "PID is #{retrieve_pid} from PID file #{pid_file.inspect}"
+    @piper.parent {
+      @piper.timeout = 0
+      wait_for_startup
+      exit!(0)
+    }
+
+    @piper.child { run_startup_command }
+  end
+
+  # Stop the daemon process. If a shutdown command has been defined, it will
+  # be called to stop the daemon process. Otherwise, SIGINT will be sent to
+  # the daemon process to terminate it.
+  #
+  def shutdown
+    return unless alive?
+
+    case shutdown_command
+    when nil; kill
+    when String; exec(shutdown_command)
+    when Array; exec(*shutdown_command)
+    when Proc, Method; shutdown_command.call
+    when ::Servolux::Server; shutdown_command.shutdown
+    else
+      raise Error, "Unrecognized shutdown command #{shutdown_command.inspect}"
     end
 
-    daemonize
+    wait_for_shutdown
   end
 
   # Returns +true+ if the daemon processis currently running. Returns
@@ -190,7 +280,6 @@ class Servolux::Daemon
     pid = retrieve_pid
     logger.info "Killing PID #{pid} with #{signal}"
     Process.kill(signal, pid)
-    wait_for_shutdown
   rescue Errno::EINVAL
     logger.error "Failed to kill PID #{pid} with #{signal}: " \
                  "'#{signal}' is an invalid or unsupported signal number."
@@ -220,19 +309,6 @@ class Servolux::Daemon
 
   private
 
-  def daemonize
-    logger.debug "About to fork ..."
-
-    @piper = ::Servolux::Piper.daemon(nochdir, noclose)
-
-    @piper.parent {
-      wait_for_startup
-      exit!(0)
-    }
-
-    @piper.child { run_startup_command }
-  end
-
   def run_startup_command
     case startup_command
     when String; exec(startup_command)
@@ -245,7 +321,7 @@ class Servolux::Daemon
 
   rescue Exception => err
     unless err.is_a?(SystemExit)
-     logger.fatal err
+      logger.fatal err
       @piper.puts err
     end
   ensure
@@ -254,9 +330,10 @@ class Servolux::Daemon
 
   def exec( *args )
     logger.debug "Calling: exec(*#{args.inspect})"
-    std = [STDIN, STDOUT, STDERR, @piper.write_io]
+    skip = [STDIN, STDOUT, STDERR]
+    skip << @piper.write_io if @piper
     ObjectSpace.each_object(IO) { |obj|
-      next if std.include? obj
+      next if skip.include? obj
       obj.close rescue nil
     }
     Kernel.exec(*args)
@@ -279,56 +356,19 @@ class Servolux::Daemon
   def wait_for_startup
     logger.debug "Waiting for #{name.inspect} to startup."
 
-    begin
-      started = wait_for {
-        rv = started?
-        err = @piper.gets; raise err unless err.nil?
-        rv
-      }
-
-      if started
-        logger.info 'Server has daemonized.'
-        return
-      end
-    rescue Exception => err
-      child_err = @piper.gets
-      raise child_err || err
-    ensure
-      @piper.close
-    end
-
-    # if the daemon doesn't fork into the background in time, then kill it.
-    force_kill
-  end
-
-  def force_kill
-    pid = retrieve_pid
-
-    t = Thread.new {
-      begin
-        sleep 7
-        unless Thread.current[:stop]
-          Process.kill('KILL', pid)
-          Process.waitpid(pid)
-        end
-      rescue Exception
-      end
+    started = wait_for {
+      rv = started?
+      err = @piper.gets
+      raise StartupError, "Child raised error: #{err.inspect}" unless err.nil?
+      rv
     }
 
-    Process.kill('TERM', pid) rescue nil
-    Process.waitpid(pid) rescue nil
-    t[:stop] = true
-    t.run if t.status
-    t.join
-
     raise Timeout, "#{name.inspect} failed to startup in a timely fashion. " \
-                   "The timeout is set at #{timeout} seconds."
+                   "The timeout is set at #{timeout} seconds." unless started
 
-  rescue Errno::ENOENT
-    raise Timeout, "Could not find a PID file at #{pid_file.inspect}."
-  rescue Errno::EACCES => err
-    raise Timeout, "You do not have access to the PID file at " \
-                   "#{pid_file.inspect}: #{err.message}"
+    logger.info 'Server has daemonized.'
+  ensure
+    @piper.close
   end
 
   def wait_for_shutdown
@@ -340,14 +380,14 @@ class Servolux::Daemon
 
   def wait_for
     start = Time.now
-    nap_time = 0.1
+    nap_time = 0.2
 
     loop do
       sleep nap_time
 
       diff = Time.now - start
       nap_time = 2*nap_time
-      nap_time = diff + 0.1 if diff < nap_time
+      nap_time = 0.2 if nap_time > 1.6
 
       break true if yield
       break false if diff >= timeout

data/lib/servolux/piper.rb

@@ -66,6 +66,7 @@ class Servolux::Piper
     piper = self.new(:timeout => 1)
     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.child {
@@ -83,7 +84,7 @@ class Servolux::Piper
 
       piper.puts Process.pid
     }
-    piper
+    return piper
   end
 
   # The timeout in seconds to wait for puts / gets commands.
@@ -121,7 +122,11 @@ class Servolux::Piper
     end
 
     @timeout = opts.getopt(:timeout, 0)
-    @read_io, @write_io = IO.pipe
+    if defined? ::Encoding
+      @read_io, @write_io = IO.pipe('ASCII-8BIT')    # encoding for Ruby 1.9
+    else
+      @read_io, @write_io = IO.pipe
+    end
     @child_pid = Kernel.fork
 
     if child?

data/lib/servolux/server.rb

@@ -99,6 +99,7 @@
 #
 #    module DebugSignal
 #      def usr1
+#        @old_log_level ||= nil
 #        if @old_log_level
 #          logger.level = @old_log_level
 #          @old_log_level = nil
@@ -127,7 +128,7 @@ class Servolux::Server
   Error = Class.new(::Servolux::Error)
 
   attr_reader   :name
-  attr_writer   :logger
+  attr_accessor :logger
   attr_writer   :pid_file
 
   # call-seq:
@@ -144,6 +145,8 @@ class Servolux::Server
   #
   def initialize( name, opts = {}, &block )
     @name = name
+    @activity_thread = nil
+    @activity_thread_running = false
 
     self.logger   = opts.getopt :logger
     self.pid_file = opts.getopt :pid_file
@@ -185,14 +188,6 @@ class Servolux::Server
   alias :term :stop         # handles the TERM signal
   private :start, :stop
 
-  # Returns the logger instance used by the server. If none was given, then
-  # a logger is created from the Logging framework (see the Logging rubygem
-  # for more information).
-  #
-  def logger
-    @logger ||= Logging.logger[self]
-  end
-
   # Returns the PID file name used by the server. If none was given, then
   # the server name is used to create a PID file name.
   #

data/lib/servolux/threaded.rb

@@ -40,7 +40,7 @@ module Servolux::Threaded
   #
   def run
     raise NotImplementedError,
-         'This method must be defined by the threaded object.'
+         'The run method must be defined by the threaded object.'
   end
 
   # Start the activity thread. If already started this method will return
@@ -64,30 +64,33 @@ module Servolux::Threaded
           break unless running?
           run
         }
-      rescue Exception => e
-        logger.fatal e
+      rescue Exception => err
+        @activity_thread_running = false
+        logger.fatal err unless err.is_a?(SystemExit)
+        raise err
       end
     }
     after_starting if self.respond_to?(:after_starting)
     self
   end
 
-  # Stop the activity thread. If already stopped  this method will return
-  # without taking any action.
+  # Stop the activity thread. If already stopped this method will return
+  # without taking any action. Otherwise, this method does not return until
+  # the activity thread has died or until _limit_ seconds have passed.
   #
   # If the including class defines a 'before_stopping' method, it will be
   # called before the thread is stopped. Likewise, if the including class
   # defines an 'after_stopping' method, it will be called after the thread
   # has stopped.
   #
-  def stop
+  def stop( limit = nil )
     return self unless running?
     logger.debug "Stopping"
 
     @activity_thread_running = false
     before_stopping if self.respond_to?(:before_stopping)
     @activity_thread.wakeup
-    @activity_thread.join
+    join limit
     @activity_thread = nil
     after_stopping if self.respond_to?(:after_stopping)
     self
@@ -101,10 +104,8 @@ module Servolux::Threaded
   # with +nil+.
   #
   def join( limit = nil )
-    @activity_thread.join limit
-    self
-  rescue NoMethodError
-    return self
+    return if @activity_thread.nil?
+    @activity_thread.join(limit) ? self : nil
   end
 
   # Returns +true+ if the activity thread is running. Returns +false+
@@ -114,6 +115,22 @@ module Servolux::Threaded
     @activity_thread_running
   end
 
+  # Returns the status of threaded object.
+  #
+  #    'sleep'    : sleeping or waiting on I/O
+  #    'run'      : executing
+  #    'aborting' : aborting
+  #    false      : not running or terminated normally
+  #    nil        : terminated with an exception
+  #
+  # If this method returns +nil+, then calling join on the threaded object
+  # will cause the exception to be raised in the calling thread.
+  #
+  def status
+    return false if @activity_thread.nil?
+    @activity_thread.status
+  end
+
   # Sets the number of seconds to sleep between invocations of the
   # threaded object's 'run' method.
   #
@@ -128,6 +145,26 @@ module Servolux::Threaded
     @activity_thread_interval
   end
 
+  # :stopdoc:
+  #
+  # The JRuby platform has an implementation error in it's Thread#join
+  # method. In the Matz Ruby Interpreter, Thread#join with a +nil+ argument
+  # will sleep forever; in the JRuby implementation, join will return
+  # immediately.
+  #
+  if 'java' == RUBY_PLATFORM
+    undef :join
+    def join( limit = nil )
+      return if @activity_thread.nil?
+      if limit.nil?
+        @activity_thread.join ? self : nil
+      else
+        @activity_thread.join(limit) ? self : nil
+      end
+    end
+  end
+  # :startdoc:
+
 end  # module Servolux::Threaded
 
 # EOF

data/spec/piper_spec.rb

@@ -0,0 +1,110 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+if Servolux.fork?
+
+describe Servolux::Piper do
+
+  before :each do
+    @piper = nil
+  end
+
+  after :each do
+    next if @piper.nil?
+    @piper.puts :die
+    @piper.close
+    @piper = nil
+  end
+
+  it 'only understands three file modes' do
+    %w[r w rw].each do |mode|
+      lambda {
+        piper = Servolux::Piper.new(mode)
+        piper.child { piper.close; exit! }
+        piper.parent { piper.close }
+      }.should_not raise_error
+    end
+
+    lambda { Servolux::Piper.new('f') }.should raise_error(
+        ArgumentError, 'Unsupported mode "f"')
+  end
+
+  it 'enables communication between parents and children' do
+    @piper = Servolux::Piper.new 'rw', :timeout => 2
+
+    @piper.child {
+      loop {
+        obj = @piper.gets
+        if :die == obj
+          @piper.close; exit!
+        end
+        @piper.puts obj unless obj.nil?
+      }
+    }
+
+    @piper.parent {
+      @piper.puts 'foo bar baz'
+      @piper.gets.should == 'foo bar baz'
+
+      @piper.puts %w[one two three]
+      @piper.gets.should == %w[one two three]
+
+      @piper.puts('Returns # of bytes written').should > 0
+      @piper.gets.should == 'Returns # of bytes written'
+
+      @piper.puts 1
+      @piper.puts 2
+      @piper.puts 3
+      @piper.gets.should == 1
+      @piper.gets.should == 2
+      @piper.gets.should == 3
+
+      @piper.timeout = 0
+      @piper.readable?.should be_false
+    }
+  end
+
+  it 'sends signals from parent to child' do
+    @piper = Servolux::Piper.new :timeout => 2
+
+    @piper.child {
+      Signal.trap('USR2') { @piper.puts "'USR2' was received" rescue nil }
+      Signal.trap('INT') {
+        @piper.puts "'INT' was received" rescue nil
+        @piper.close
+        exit!
+      }
+      Thread.new { sleep 7; exit! }
+      @piper.puts :ready
+      loop { sleep }
+    }
+
+    @piper.parent {
+      @piper.gets.should == :ready
+
+      @piper.signal 'USR2'
+      @piper.gets.should == "'USR2' was received"
+
+      @piper.signal 'INT'
+      @piper.gets.should == "'INT' was received"
+    }
+  end
+
+  it 'creates a daemon process' do
+    @piper = Servolux::Piper.daemon(true, true)
+
+    @piper.child {
+      @piper.puts Process.ppid
+      @piper.close
+      exit!
+    }
+
+    @piper.parent {
+      @piper.gets.should == 1
+    }
+  end
+
+end
+end  # if Servolux.fork?
+
+# EOF

data/spec/server_spec.rb

@@ -0,0 +1,69 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Servolux::Server do
+  base = Class.new(Servolux::Server) do
+    def initialize( &block )
+      super('Test Server', :logger => Logging.logger['Servolux'], &block)
+    end
+    def run() sleep; end
+  end
+
+  before :each do
+    @server = base.new
+    File.delete @server.pid_file if test(?f, @server.pid_file)
+  end
+
+  after :each do
+    File.delete @server.pid_file if test(?f, @server.pid_file)
+  end
+
+  it 'generates a PID file' do
+    test(?e, @server.pid_file).should be_false
+
+    t = Thread.new {@server.startup}
+    Thread.pass until @server.status == 'sleep'
+    test(?e, @server.pid_file).should be_true
+
+    @server.shutdown
+    Thread.pass 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.status == 'sleep'
+    @server.running?.should be_true
+
+    Process.kill('INT', $$)
+    Thread.pass until t.status == false
+    @server.running?.should be_false
+  end
+
+  it 'responds to signals that have defined handlers' do
+    class << @server
+      def hup() logger.info 'hup was called'; end
+      def usr1() logger.info 'usr1 was called'; end
+      def usr2() logger.info 'usr2 was called'; end
+    end
+
+    t = Thread.new {@server.startup}
+    Thread.pass until @server.status == 'sleep'
+    @log_output.readline
+
+    Process.kill('USR1', $$)
+    @log_output.readline.strip.should == 'INFO  Servolux : usr1 was called'
+
+    Process.kill('HUP', $$)
+    @log_output.readline.strip.should == 'INFO  Servolux : hup was called'
+
+    Process.kill('USR2', $$)
+    @log_output.readline.strip.should == 'INFO  Servolux : usr2 was called'
+
+    Process.kill('TERM', $$)
+    Thread.pass until t.status == false
+    @server.running?.should be_false
+  end
+end
+
+# EOF

data/spec/spec_helper.rb

@@ -9,6 +9,8 @@ require 'spec/logging_helper'
 require File.expand_path(
     File.join(File.dirname(__FILE__), %w[.. lib servolux]))
 
+include Logging.globally
+
 Spec::Runner.configure do |config|
   include Spec::LoggingHelper
   config.capture_log_messages

data/spec/threaded_spec.rb

@@ -0,0 +1,105 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Servolux::Threaded do
+
+  base = Class.new do
+    include Servolux::Threaded
+    def initialize
+      @activity_thread_running = false
+      @activity_thread_interval = 0
+    end
+    def pass( val = 'sleep' )
+      Thread.pass until status == val
+    end
+  end
+
+  it "let's you know that it is running" do
+    klass = Class.new(base) do
+      def run() sleep 1; end
+    end
+
+    obj = klass.new
+    obj.interval = 0
+    obj.running?.should be_false
+
+    obj.start
+    obj.running?.should be_true
+    obj.pass
+
+    obj.stop(2)
+    obj.running?.should be_false
+  end
+
+  it "stops even when sleeping in the run method" do
+    klass = Class.new(base) do
+      attr_reader :stopped
+      def run() sleep; end
+      def after_starting() @stopped = false; end
+      def after_stopping() @stopped = true; end
+    end
+
+    obj = klass.new
+    obj.interval = 0
+    obj.stopped.should be_nil
+
+    obj.start
+    obj.stopped.should be_false
+    obj.pass
+
+    obj.stop(2)
+    obj.stopped.should be_true
+  end
+
+  it "calls all the before and after hooks" do
+    klass = Class.new(base) do
+      attr_accessor :ary
+      def run() sleep 1; end
+      def before_starting() ary << 1; end
+      def after_starting() ary << 2; end
+      def before_stopping() ary << 3; end
+      def after_stopping() ary << 4; end
+    end
+
+    obj = klass.new
+    obj.interval = 86400
+    obj.ary = []
+
+    obj.start
+    obj.ary.should == [1,2]
+    obj.pass
+
+    obj.stop(2)
+    obj.ary.should == [1,2,3,4]
+  end
+
+  it "dies when an exception is thrown" do
+    klass = Class.new(base) do
+      def run() raise 'ni'; end
+    end
+
+    obj = klass.new
+
+    obj.start
+    obj.pass nil
+
+    obj.running?.should be_false
+    @log_output.readline
+    @log_output.readline.chomp.should == "FATAL  Object : <RuntimeError> ni"
+
+    lambda { obj.join }.should raise_error(RuntimeError, 'ni')
+  end
+
+  it "complains loudly if you don't have a run method" do
+    obj = base.new
+    obj.start
+    obj.pass nil
+
+    @log_output.readline
+    @log_output.readline.chomp.should == "FATAL  Object : <NotImplementedError> The run method must be defined by the threaded object."
+
+    lambda { obj.join }.should raise_error(NotImplementedError, 'The run method must be defined by the threaded object.')
+  end
+end
+
+# EOF

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: servolux
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tim Pease
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-19 00:00:00 -06:00
+date: 2009-06-29 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +42,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.5.0
     version: 
-description: "Threads : Servers : Forks : Daemons"
+description: "Threads : Servers : Forks : Daemons : Serv-O-Lux has them all!"
 email: tim.pease@gmail.com
 executables: []
 
@@ -56,12 +56,16 @@ files:
 - README.rdoc
 - Rakefile
 - lib/servolux.rb
+- lib/servolux/child.rb
 - lib/servolux/daemon.rb
 - lib/servolux/piper.rb
 - lib/servolux/server.rb
 - lib/servolux/threaded.rb
+- spec/piper_spec.rb
+- spec/server_spec.rb
 - spec/servolux_spec.rb
 - spec/spec_helper.rb
+- spec/threaded_spec.rb
 - tasks/ann.rake
 - tasks/bones.rake
 - tasks/gem.rake
@@ -101,6 +105,6 @@ rubyforge_project: codeforpeople
 rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
-summary: "Threads : Servers : Forks : Daemons"
+summary: "Threads : Servers : Forks : Daemons : Serv-O-Lux has them all!"
 test_files: []