pidfile 0.2.0 → 0.3.0

data/README.rdoc

@@ -17,15 +17,14 @@ Install the pidfile gem:
 
 == Gettings Started
 
-The pidfile gem is easy to use and only requires the addition of a single line 
-of code; something like this:
+The pidfile gem is easy to use and only requires the instantiation of the
+pidfile, like so:
 
-  pf = PidFile.new unless PidFile.running?
+  pf = PidFile.new
 
 Of course there is other functionality, but if you are just wanting to keep a
 process from running more than once, this is all you need.
 
-
 === Arguments
 
 PidFile creates file to store the process ID (PID).  By default, process ID
@@ -40,6 +39,18 @@ class.
 
   PidFile.new(:piddir => '/var/lock', :pidfile => "awesome.pid")
 
+== Miscellaneous
+
+=== Why isn't this a singleton?
+
+My main concern is how it would behave when a process is forked multiple times.
+Each new process would get its own PID, but I wasn't sure how using a singleton
+would affect this; if the interrelationship of the processes would keep the
+object from correctly identifying the correct pidfile. 
+
+Anyway, I like the flexibility that not using a singleton offers, and I guess
+I'd rather ask you not to do something bad rather than restraining you.
+
 == Copyright
 
 Copyright(c) 2010 Samuel Mullen (samullen). See LICENSE for details

data/lib/pidfile.rb

@@ -1,7 +1,9 @@
 class PidFile
-  attr_accessor :pidfile, :piddir
+  attr_reader :pidfile, :piddir, :pidpath
 
-  VERSION = '0.2.0'
+  class DuplicateProcessError < RuntimeError; end
+
+  VERSION = '0.3.0'
 
   DEFAULT_OPTIONS = {
     :pidfile => File.basename($0, File.extname($0)) + ".pid",
@@ -11,6 +13,7 @@ class PidFile
   def initialize(*args)
     opts = {}
 
+    #----- set options -----#
     case
     when args.length == 0 then
     when args.length == 1 && args[0].class == Hash then
@@ -27,17 +30,29 @@ class PidFile
 
     @piddir     = opts[:piddir]
     @pidfile    = opts[:pidfile]
+    @pidpath    = File.join(@piddir, @pidfile)
     @fh         = nil
 
+    #----- Does the pidfile or pid exist? -----#
+    if self.pidfile_exists?
+      if self.class.running?(@pidpath)
+        raise DuplicateProcessError, "Process (#{$0} - #{self.class.pid(@pidpath)}) is already running."
+        
+        exit! # exit without removing the existing pidfile
+      end
+
+      self.release
+    end
+
+    #----- create the pidfile -----#
     create_pidfile
 
     at_exit { release }
   end
 
-  # Returns the fullpath to the file containing the process ID (PID)
-  def pidpath
-    File.join(@piddir, @pidfile)
-  end
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+  # Instance Methods
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
 
   # Returns the PID, if any, of the instantiating process
   def pid
@@ -76,6 +91,17 @@ class PidFile
     File.mtime(self.pidpath)
   end
 
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+  # Class Methods
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+
+  # Returns the PID, if any, of the instantiating process
+  def self.pid(path=nil)
+    if pidfile_exists?(path)
+      open(path, 'r').read.to_i
+    end
+  end
+
   # class method for determining the existence of pidfile
   def self.pidfile_exists?(path=nil)
     path ||= File.join(DEFAULT_OPTIONS[:piddir], DEFAULT_OPTIONS[:pidfile])
@@ -85,30 +111,30 @@ class PidFile
 
   # boolean stating whether the calling program is already running
   def self.running?(path=nil)
+    calling_pid = nil
     path ||= File.join(DEFAULT_OPTIONS[:piddir], DEFAULT_OPTIONS[:pidfile])
 
     if pidfile_exists?(path)
-      pid = open(path, 'r').read.to_i
-    else
-      pid = nil
+      calling_pid = pid(path)
     end
 
-    return false unless pid && (pid != Process.pid)
-
-    process_exists?(pid)
+    process_exists?(calling_pid)
   end
 
 private
 
   # Writes the process ID to the pidfile and defines @pid as such
   def create_pidfile
+    # Once the filehandle is created, we don't release until the process dies.
     @fh = open(self.pidpath, "w")
     @fh.flock(File::LOCK_EX | File::LOCK_NB) || raise
     @pid = Process.pid
     @fh.puts @pid
+    @fh.flush
+    @fh.rewind
   end
 
-  # removes the pidfile. 
+  # removes the pidfile.
   def remove_pidfile
     File.unlink(self.pidpath) if self.pidfile_exists?
   end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: pidfile
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Samuel Mullen
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-14 00:00:00 -05:00
+date: 2010-07-27 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -41,23 +42,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A basic library for creating lockfiles for processes