servolux 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c744b0af533fabea800e187f1008917cf2c7aacf
-  data.tar.gz: e46bfba16ebbcfac37aa4e4d0fa44bb6e090e403
+  metadata.gz: 581567ae92a495cdeb92737c979d52e6bd8cf996
+  data.tar.gz: 0f887e81fc0a8b78e1f340578f2183b460a27ca7
 SHA512:
-  metadata.gz: 1f8e41c57443b49a4a4ba6766daa95933e7e6a9827e759aee2284828589e29c13536041ba70e196ac945fa5cc1ee96c61124cfd0726881990634c4b4f9b32372
-  data.tar.gz: 555e8ad6764063743afca6635515f445e8e8e04b509a4143fbda4026cc9074b98d9310f36da0f37c59083f127cba8a10df44738dda4b1590d52ea9a76d83af9c
+  metadata.gz: b67919d827ef8ca1e956918d631bbb2a1ffebcedf3334c4197664c674f340910c0156b6973e476f62c1030069a49332752c7847fab262ee219f633260d971e3f
+  data.tar.gz: 4cb69e76d39fece3215048a9032bfa3904888061dc1676b818500bca238503f0659e67ee583d98efd9286caf2abc30ccf0e27b283c8deccc62b5e1ec5fe3c558

data/README.md

@@ -8,7 +8,7 @@ by Tim Pease [![](https://secure.travis-ci.org/TwP/servolux.png)](http://travis-
 
 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 supporting both 1.8 and 1.9
+documented and tested. It works with Ruby and JRuby supporting 1.9 and 2.0
 interpreters.
 
 ### Features
@@ -42,6 +42,9 @@ process to die if it does not exit in a given amount of time.
 -- provides a pre-forking worker pool for executing tasks in parallel using
 multiple processes.
 
+[Servolux::PidFile](http://www.rubydoc.info/github/TwP/servolux/Servolux/PidFile)
+-- provides PID file management and process signaling and liveness checks.
+
 All the documentation is available online at http://rdoc.info/projects/TwP/servolux
 
 ### Install

data/examples/echo.rb

@@ -35,7 +35,7 @@ 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,_ = acceptor.accept
   socket.write "child #$$ echo> "
   socket.flush
   message = socket.gets

data/lib/servolux.rb

@@ -35,10 +35,8 @@ module Servolux
   def self.fork?
     RUBY_PLATFORM != 'java' and test(?e, '/dev/null')
   end
-
 end
 
-%w[version threaded server piper daemon child prefork].each do |lib|
+%w[version null_logger threaded pid_file server piper daemon child prefork].each do |lib|
   require Servolux.libpath('servolux', lib)
 end
-

data/lib/servolux/daemon.rb

@@ -77,7 +77,7 @@ class Servolux::Daemon
 
   attr_accessor :name
   attr_accessor :logger
-  attr_accessor :pid_file
+  attr_reader   :pid_file
   attr_reader   :startup_command
   attr_accessor :shutdown_command
   attr_accessor :timeout
@@ -153,10 +153,10 @@ class Servolux::Daemon
   def initialize( opts = {} )
     @piper = nil
     @logfile_reader = nil
+    @pid_file = nil
 
     self.name     = opts.fetch(:name, nil)
-    self.logger   = opts.fetch(:logger, nil)
-    self.pid_file = opts.fetch(:pid_file, nil)
+    self.logger   = opts.fetch(:logger, Servolux::NullLogger())
     self.startup_command  = opts.fetch(:server, nil) || opts.fetch(:startup_command, nil)
     self.shutdown_command = opts.fetch(:shutdown_command, nil)
     self.timeout  = opts.fetch(:timeout, 30)
@@ -167,6 +167,8 @@ class Servolux::Daemon
     self.after_fork  = opts.fetch(:after_fork, nil)
     self.before_exec = opts.fetch(:before_exec, nil)
 
+    self.pid_file = opts.fetch(:pid_file, name) if pid_file.nil?
+
     yield self if block_given?
 
     ary = %w[name logger pid_file startup_command].map { |var|
@@ -198,14 +200,35 @@ class Servolux::Daemon
     @startup_command = val
     return unless val.is_a?(::Servolux::Server)
 
-    @name = val.name
-    @logger = val.logger
-    @pid_file = val.pid_file
+    self.name = val.name
+    self.logger = val.logger
+    self.pid_file = val.pid_file
     @shutdown_command = nil
   end
   alias :server= :startup_command=
   alias :server  :startup_command
 
+  # Set the PID file to the given `value`. If a PidFile instance is given, then
+  # it is used. If a name is given, then that name is used to create a PifFile
+  # instance.
+  #
+  # value - The PID file name or a PidFile instance.
+  #
+  # Raises an ArgumentError if the `value` cannot be used as a PID file.
+  def pid_file=( value )
+    @pid_file =
+      case value
+      when Servolux::PidFile
+        value
+      when String
+        path = File.dirname(value)
+        fn = File.basename(value, ".pid")
+        Servolux::PidFile.new(:name => fn, :path => path, :logger => logger)
+      else
+        raise ArgumentError, "#{value.inspect} cannot be used as a PID file"
+      end
+  end
+
   # Assign the log file name. This log file will be monitored to determine
   # if the daemon process is running.
   #
@@ -289,15 +312,7 @@ class Servolux::Daemon
   # @return [Boolean]
   #
   def alive?
-    pid = retrieve_pid
-    Process.kill(0, pid)
-    true
-  rescue Errno::ESRCH, Errno::ENOENT
-    false
-  rescue Errno::EACCES => err
-    logger.error "You do not have access to the PID file at " \
-                 "#{pid_file.inspect}: #{err.message}"
-    false
+    pid_file.alive?
   end
 
   # Send a signal to the daemon process identified by the PID file. The
@@ -309,32 +324,9 @@ class Servolux::Daemon
   # @return [Daemon] self
   #
   def kill( signal = 'INT' )
-    signal = Signal.list.invert[signal] if signal.is_a?(Integer)
-    pid = retrieve_pid
-    logger.info "Killing PID #{pid} with #{signal}"
-    Process.kill(signal, pid)
-    self
-  rescue Errno::EINVAL
-    logger.error "Failed to kill PID #{pid} with #{signal}: " \
-                 "'#{signal}' is an invalid or unsupported signal number."
-  rescue Errno::EPERM
-    logger.error "Failed to kill PID #{pid} with #{signal}: " \
-                 "Insufficient permissions."
-  rescue Errno::ESRCH
-    logger.error "Failed to kill PID #{pid} with #{signal}: " \
-                 "Process is deceased or zombie."
-  rescue Errno::EACCES => err
-    logger.error err.message
-  rescue Errno::ENOENT => err
-    logger.error "Could not find a PID file at #{pid_file.inspect}. " \
-                 "Most likely the process is no longer running."
-  rescue Exception => err
-    unless err.is_a?(SystemExit)
-      logger.error "Failed to kill PID #{pid} with #{signal}: #{err.message}"
-    end
+    pid_file.kill signal
   end
 
-
 private
 
   def run_startup_command
@@ -373,11 +365,7 @@ private
   end
 
   def retrieve_pid
-    @piper ? @piper.pid : Integer(File.read(pid_file).strip)
-  rescue TypeError
-    raise Error, "A PID file was not specified."
-  rescue ArgumentError
-    raise Error, "#{pid_file.inspect} does not contain a valid PID."
+    @piper ? @piper.pid : pid_file.pid
   end
 
   def started?
@@ -475,6 +463,4 @@ private
     end
   end
   # :startdoc:
-
 end
-

data/lib/servolux/null_logger.rb

@@ -0,0 +1,19 @@
+require "singleton"
+require "logger"
+
+module Servolux
+  # A "do nothing" implementation of the standard Ruby Logger class.
+  class NullLogger < Logger
+    include Singleton
+    def initialize(*args); end
+    def add(*args, &block); end
+  end
+
+  # Syntactic sugar for getting the null logger instance.
+  #
+  #   Servolux::NullLogger()   #=> NullLogger singleton instance
+  #
+  def self.NullLogger
+    NullLogger.instance
+  end
+end

data/lib/servolux/pid_file.rb

@@ -0,0 +1,172 @@
+# == Synopsis
+# The PidFile manages the lifecycle of a PID file.
+#
+# == Details
+# A PID file contains the process ID of a given program. This file can be used
+# by the program to indicate that it started successfully. The file can be used
+# programmatically to look up the process ID and send signals to the program.
+# The file can be used to ensure two instances of the same program are not
+# started at the same time.
+#
+# The PidFile class supports creating and deleting PID files. Methods are
+# provided to check if the program associated with the PID is `alive?`. Signals
+# can be sent to the program using the `kill` method.
+#
+# == Examples
+#
+# Here is a simple example creating a PID file in the "/var/run" directory.
+#
+#   pid_file = Servolux::PidFile.new(:name => "test", :path => "/var/run")
+#   pid_file.filename  #=> "/var/run/test.pid"
+#   pid_file.write
+#
+# From another process we can access this PID file and send a `HUP` signal to
+# the program.
+#
+#   pid_file = Servolux::PidFile.new(:name => "test", :path => "/var/run")
+#   pid_file.kill("HUP") if pid_file.alive?
+#
+class Servolux::PidFile
+
+  DEFAULT_MODE = 0640
+
+  attr_accessor :name     # the process name
+  attr_accessor :path     # the path to the PID file
+  attr_accessor :mode     # PID file permissions mode
+  attr_accessor :logger   # logger for outputting messages
+
+  # Create a new PID file instance.
+  #
+  # opts - The options Hash
+  #   :name   - the name of the program
+  #   :path   - path to the PID file location
+  #   :mode   - file permissions mode
+  #   :logger - logger for outputting messages
+  #
+  def initialize( opts = {} )
+    @name   = opts.fetch(:name, $0)
+    @path   = opts.fetch(:path, ".")
+    @mode   = opts.fetch(:mode, DEFAULT_MODE)
+    @logger = opts.fetch(:logger, Servolux::NullLogger())
+
+    yield self if block_given?
+  end
+
+  # Returns the full name of the PID file including path and extension.
+  def filename
+    fn = name.to_s.downcase.tr(" ","_") + ".pid"
+    fn = File.join(path, fn) unless path.nil?
+    fn
+  end
+
+  # Writes the given `pid` to the PID file. The `pid` defaults to the current
+  # process ID.
+  #
+  # pid - The process ID to write to the file
+  #
+  # Returns the filename of PID file.
+  # Raises Errno::EACCESS if you do not have permission to write the file.
+  def write( pid = Process.pid )
+    fn = filename
+    logger.debug "Writing pid file #{fn.inspect}"
+    File.open(fn, 'w', mode) { |fd| fd.write(pid.to_s) }
+    fn
+  end
+
+  # Delete the PID file if it exists. This method first checks that the current
+  # process PID is the same as the PID stored in the file. If the PIDs do not
+  # match, then this method returns `nil` without taking any action.
+  #
+  # Returns the filename of the deleted file or `nil` if no action was taken.
+  # Raises Errno::EACCESS if you do not have permission to delete the file.
+  def delete
+    return unless pid == Process.pid
+    fn = filename
+    logger.debug "Deleting pid file #{fn.inspect}"
+    File.delete fn
+    fn
+  end
+
+  # Forcibly delete the PID file if it exists. This method does NOT check that
+  # the current process PID against the PID stored in the file.
+  #
+  # Returns the filename of the deleted file or `nil` if no action was taken.
+  # Raises Errno::EACCESS if you do not have permission to delete the file.
+  def delete!
+    return unless exist?
+    fn = filename
+    logger.debug "Deleting pid file #{fn.inspect}"
+    File.delete fn
+    fn
+  end
+
+  # Returns `true` if the PID file exists. Returns `false` otherwise.
+  def exist?
+    File.exist? filename
+  end
+
+  # Returns the numeric PID read from the file or `nil` if the file does not
+  # exist. If you do not have permission to access the file `nil` is returned.
+  def pid
+    fn = filename
+    Integer(File.read(fn).strip) if File.exist?(fn)
+  rescue Errno::EACCES => err
+    logger.error "You do not have access to the PID file at " \
+                 "#{fn.inspect}: #{err.message}"
+    nil
+  end
+
+  # Returns `true` if the process is currently running. Returns `false` if this
+  # is not the case. The status of the process is determined by sending signal 0
+  # to the process.
+  def alive?
+    pid = self.pid
+    return if pid.nil?
+
+    Process.kill(0, pid)
+    true
+  rescue Errno::ESRCH, Errno::ENOENT
+    false
+  end
+
+  # Send a signal the process identified by the PID file. The default signal to
+  # send is 'INT' (2). The signal can be given either as a string or a signal
+  # number.
+  #
+  # signal - The signal to send to the process (String or Integer)
+  #
+  # Returns an Integer or `nil` if an error was encountered.
+  def kill( signal = 'INT' )
+    pid = self.pid
+    return if pid.nil?
+
+    signal = Signal.list.invert[signal] if signal.is_a?(Integer)
+    logger.info "Killing PID #{pid} with #{signal}"
+    Process.kill(signal, pid)
+
+  rescue Errno::EINVAL
+    logger.error "Failed to kill PID #{pid} with #{signal}: " \
+                 "'#{signal}' is an invalid or unsupported signal number."
+    nil
+  rescue Errno::EPERM
+    logger.error "Failed to kill PID #{pid} with #{signal}: " \
+                 "Insufficient permissions."
+    nil
+  rescue Errno::ESRCH
+    logger.error "Failed to kill PID #{pid} with #{signal}: " \
+                 "Process is deceased or zombie."
+    nil
+  rescue Errno::EACCES => err
+    logger.error err.message
+    nil
+  rescue Errno::ENOENT => err
+    logger.error "Could not find a PID file at #{pid_file.inspect}. " \
+                 "Most likely the process is no longer running."
+    nil
+  rescue Exception => err
+    unless err.is_a?(SystemExit)
+      logger.error "Failed to kill PID #{pid} with #{signal}: #{err.message}"
+    end
+    nil
+  end
+end

data/lib/servolux/server.rb

@@ -129,12 +129,9 @@ class Servolux::Server
 
   Error = Class.new(::Servolux::Error)
 
-  DEFAULT_PID_FILE_MODE = 0640
-
   attr_reader   :name
   attr_accessor :logger
-  attr_writer   :pid_file
-  attr_accessor :pid_file_mode
+  attr_reader   :pid_file
 
   # call-seq:
   #    Server.new( name, options = {} ) { block }
@@ -153,10 +150,9 @@ class Servolux::Server
     @mutex = Mutex.new
     @shutdown = nil
 
-    self.logger        = opts.fetch(:logger, nil)
-    self.pid_file      = opts.fetch(:pid_file, nil)
-    self.pid_file_mode = opts.fetch(:pid_file_mode, DEFAULT_PID_FILE_MODE)
-    self.interval      = opts.fetch(:interval, 0)
+    self.logger   = opts.fetch(:logger, Servolux::NullLogger())
+    self.interval = opts.fetch(:interval, 0)
+    self.pid_file = opts.fetch(:pid_file, name)
 
     if block
       eg = class << self; self; end
@@ -191,12 +187,12 @@ class Servolux::Server
 
     begin
       trap_signals
-      create_pid_file
+      pid_file.write
       start
       join
       wait_for_shutdown if wait
     ensure
-      delete_pid_file
+      pid_file.delete
     end
     return self
   end
@@ -240,30 +236,29 @@ class Servolux::Server
   alias :term :shutdown    # handles the TERM signal
   private :start, :stop
 
-  # 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.
+  # Set the PID file to the given `value`. If a PidFile instance is given, then
+  # it is used. If a name is given, then that name is used to create a PifFile
+  # instance.
+  #
+  # value - The PID file name or a PidFile instance.
   #
-  def pid_file
-    @pid_file ||= name.downcase.tr(' ','_') + '.pid'
+  # Raises an ArgumentError if the `value` cannot be used as a PID file.
+  def pid_file=( value )
+    @pid_file =
+      case value
+      when Servolux::PidFile
+        value
+      when String
+        path = File.dirname(value)
+        fn = File.basename(value, ".pid")
+        Servolux::PidFile.new(:name => fn, :path => path, :logger => logger)
+      else
+        raise ArgumentError, "#{value.inspect} cannot be used as a PID file"
+      end
   end
 
   private
 
-  def create_pid_file
-    logger.debug "Server #{name.inspect} creating pid file #{pid_file.inspect}"
-    File.open(pid_file, 'w', pid_file_mode) {|fd| fd.write(Process.pid.to_s)}
-  end
-
-  def delete_pid_file
-    if test(?f, pid_file)
-      pid = Integer(File.read(pid_file).strip)
-      return unless pid == Process.pid
-
-      logger.debug "Server #{name.inspect} removing pid file #{pid_file.inspect}"
-      File.delete(pid_file)
-    end
-  end
-
   def trap_signals
     SIGNALS.each do |sig|
       method = sig.downcase.to_sym

data/lib/servolux/version.rb

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

data/spec/daemon_spec.rb

@@ -1,5 +1,4 @@
 require File.expand_path('../spec_helper', __FILE__)
-require 'logger'
 require 'fileutils'
 
 if Servolux.fork?

data/spec/pid_file_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Servolux::PidFile do
+  before :all do
+    tmp = Tempfile.new "servolux-pid-file"
+    @path = tmp.path; tmp.unlink
+    FileUtils.mkdir @path
+  end
+
+  after :all do
+    FileUtils.rm_rf @path
+  end
+
+  before :each do
+    FileUtils.rm_f Dir.glob("#@path/*.pid")
+    @pid_file = Servolux::PidFile.new \
+      :name   => "test",
+      :path   => @path,
+      :logger => Logging.logger['Servolux']
+
+    @filename = @pid_file.filename
+  end
+
+  describe "filename" do
+    it "normalizes the process name" do
+      pid = Servolux::PidFile.new :name => "Test Server"
+      expect(pid.filename).to eq("./test_server.pid")
+    end
+
+    it "includes the path" do
+      pid = Servolux::PidFile.new :name => "Test Server", :path => @path
+      expect(pid.filename).to eq("#@path/test_server.pid")
+    end
+  end
+
+  describe "creating" do
+    it "writes a PID file" do
+      expect(test(?e, @filename)).to be false
+
+      @pid_file.write(123456)
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Writing pid file "#@path/test.pid"})
+
+      pid = Integer(File.read(@filename).strip)
+      expect(pid).to eq(123456)
+    end
+
+    it "uses mode rw-r----- by default" do
+      expect(test(?e, @filename)).to be false
+
+      @pid_file.write
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Writing pid file "#@path/test.pid"})
+
+      mode = File.stat(@filename).mode & 0777
+      expect(mode).to eq(0640)
+    end
+
+    it "uses the given mode" do
+      @pid_file.mode = 0400
+      expect(test(?e, @filename)).to be false
+
+      @pid_file.write
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Writing pid file "#@path/test.pid"})
+
+      mode = File.stat(@filename).mode & 0777
+      expect(mode).to eq(0400)
+    end
+  end
+
+  describe "deleting" do
+    it "removes a PID file" do
+      expect(test(?e, @filename)).to be false
+      expect { @pid_file.delete }.not_to raise_error
+
+      @pid_file.write
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Writing pid file "#@path/test.pid"})
+
+      @pid_file.delete
+      expect(test(?e, @filename)).to be false
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Deleting pid file "#@path/test.pid"})
+    end
+
+    it "removes the PID file only from the same process" do
+      @pid_file.write(654321)
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Writing pid file "#@path/test.pid"})
+
+      @pid_file.delete
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline).to be_nil
+    end
+
+    it "can forcibly remove a PID file" do
+      @pid_file.write(135790)
+      expect(test(?e, @filename)).to be true
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Writing pid file "#@path/test.pid"})
+
+      @pid_file.delete!
+      expect(test(?e, @filename)).to be false
+      expect(@log_output.readline.chomp).to \
+        eq(%Q{DEBUG  Servolux : Deleting pid file "#@path/test.pid"})
+    end
+  end
+
+  it "returns the PID from the file" do
+    expect(@pid_file.pid).to be_nil
+
+    File.open(@filename, 'w') { |fd| fd.write(314159) }
+    expect(@pid_file.pid).to eq(314159)
+
+    File.delete(@filename)
+    expect(@pid_file.pid).to be_nil
+  end
+
+  it "reports if the process is alive" do
+    expect(@pid_file.pid).to be_nil    # there is no PID file yet
+    expect(@pid_file).not_to be_alive  # and so we cannot determine
+                                       # if the process is alive
+    @pid_file.write
+    expect(@pid_file.pid).not_to be_nil
+    expect(@pid_file).to be_alive
+  end
+end

data/spec/server_spec.rb

@@ -9,61 +9,67 @@ describe Servolux::Server do
   end
 
   base = Class.new(Servolux::Server) do
-    def initialize( &block )
-      super('Test Server', :logger => Logging.logger['Servolux'], &block)
+    def initialize
+      super('Test Server', :logger => Logging.logger['Servolux'])
     end
     def run() sleep; end
   end
 
   before :each do
     @server = base.new
-    File.delete @server.pid_file if test(?f, @server.pid_file)
+    @server.pid_file.delete
   end
 
   after :each do
     @server.shutdown
-    File.delete @server.pid_file if test(?f, @server.pid_file)
+    @server.wait_for_shutdown
   end
 
   it 'generates a PID file' do
-    expect(test(?e, @server.pid_file)).to be false
+    expect(@server.pid_file).to_not exist
 
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
-    expect(test(?e, @server.pid_file)).to be true
+    expect(@server.pid_file).to exist
 
     @server.shutdown
     wait_until { t.status == false }
-    expect(test(?e, @server.pid_file)).to be 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' }
-    expect(test(?e, @server.pid_file)).to be true
+    expect(@server.pid_file).to exist
 
-    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid"))
+    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(File.stat(@server.pid_file).mode & 0777).to eq(0640)
+
+    filename = @server.pid_file.filename
+    mode = File.stat(filename).mode & 0777
+    expect(mode).to eq(0640)
 
     @server.shutdown
     wait_until { t.status == false }
-    expect(test(?e, @server.pid_file)).to be false
+    expect(@server.pid_file).to_not exist
   end
 
   it 'generates PID file with the specified permissions' do
-    @server.pid_file_mode = 0400
+    @server.pid_file.mode = 0400
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
-    expect(test(?e, @server.pid_file)).to be true
+    expect(@server.pid_file).to exist
 
-    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid"))
+    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(File.stat(@server.pid_file).mode & 0777).to eq(0400)
+
+    filename = @server.pid_file.filename
+    mode = File.stat(filename).mode & 0777
+    expect(mode).to eq(0400)
 
     @server.shutdown
     wait_until { t.status == false }
-    expect(test(?e, @server.pid_file)).to be false
+    expect(@server.pid_file).to_not exist
   end
 
   it 'shuts down gracefully when signaled' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servolux
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Tim Pease
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-30 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones-rspec
@@ -69,7 +69,7 @@ dependencies:
 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 supporting both 1.8 and 1.9
+  documented and tested. It works with Ruby and JRuby supporting 1.9 and 2.0
   interpreters.
 email: tim.pease@gmail.com
 executables: []
@@ -89,6 +89,8 @@ files:
 - lib/servolux.rb
 - lib/servolux/child.rb
 - lib/servolux/daemon.rb
+- lib/servolux/null_logger.rb
+- lib/servolux/pid_file.rb
 - lib/servolux/piper.rb
 - lib/servolux/prefork.rb
 - lib/servolux/server.rb
@@ -97,6 +99,7 @@ files:
 - script/bootstrap
 - spec/child_spec.rb
 - spec/daemon_spec.rb
+- spec/pid_file_spec.rb
 - spec/piper_spec.rb
 - spec/prefork_spec.rb
 - spec/server_spec.rb