pidify 0.1.0-i386-linux → 0.1.1-i386-linux

data/lib/pidify.rb

@@ -45,7 +45,7 @@
 #   module Doer
 #     def self.start
 #       puts "starting"
-#       raise "Failed to start: already running (PID file exists)." if Pidify.running?
+#       raise "Failed to start: already running." if Pidify.running?
 #       Daemons.daemonize
 #       Pidify.start
 #       loop do
@@ -86,56 +86,111 @@ module Pidify
       @pid_directory + (Pathname.new($0).basename.to_s+'.pid')
     end
 
-    # Returns true if the PID file exists for this script.
-    def running?
+    # Returns true if the pid_file exists for this script.
+    def pid_exists?
       return FileTest.exists?(pid_file)
     end
 
+    # Returns true if the process using pid is running.
+    def running?
+      return false unless pid_exists?
+      begin
+        Process::kill 0, pid
+        true
+      rescue Errno::ESRCH
+        false
+      end 
+    end
+
     # Returns the PID stored in the pid_file (not necessarily the PID of this
-    # script).
+    # script).  Returns nil if no PID exists or if there is a problem with the
+    # read.
     def pid
-      dpid = nil 
-      File.open(pid_file) { |file| dpid = file.gets.chomp }
-      dpid.to_i
+      return nil unless pid_exists?
+      dpid = nil
+      begin
+        File.open(pid_file, File::RDONLY) { |file| dpid = file.gets.chomp if file.flock(File::LOCK_SH|File::LOCK_NB); file.flock(File::LOCK_UN) }
+      rescue
+        return nil
+      end
+      return dpid.to_i if dpid && dpid.to_i > 0
+      nil
     end
 
-    # Saves the PID of this script into the pid_file.  Automatically called by start.
+    # Saves the PID of this script into the pid_file.  Automatically called by
+    # start.  Returns nil if the pid file already exists.  Returns true if
+    # successful, false if there was a write problem.
     def save_pid
-      File.open(pid_file, 'w') { |file| file.puts $$ }
+      return nil if pid_exists?
+      begin
+        File.open(pid_file, File::CREAT|File::EXCL|File::WRONLY) { |file| file.puts $$ if file.flock(File::LOCK_EX); file.flock(File::LOCK_UN) }
+        true
+      rescue
+        false
+      end
     end
 
     # Deletes the PID file.  Calling stop calls this automatically, but will
     # also try to send a kill signal to the running process, if it is different
     # from this one.  BEWARE that this tries to delete whatever file is
-    # returned by pid_file and does no error checking on it!
+    # returned by pid_file and does no error checking on it!  Returns true if
+    # the delete was successful, false if there was an error, and nil if the
+    # pid file doesn't exist.
     def delete_pid
-      File.delete(pid_file) if FileTest.exists? pid_file
+      return nil unless pid_exists?
+      begin
+        # FIXME: lock first?
+        File.delete(pid_file)
+        true
+      rescue
+        false
+      end
     end
 
     # Saves the PID of this script into the pid_file by calling save_pid.
-    # Raises an exception if running? returns false.
+    # Raises an exception if pid_exists? returns false.  Returns true if
+    # successful.
     def start
-      raise "Failed to start: already running (PID file exists)." if running?
-      save_pid
+      raise "Failed to start: already running (PID file exists)." if pid_exists?
+      return true if save_pid
     end
 
     # Deletes the saved PID file and, if the PID belongs to a process different
-    # from this script, sends a kill signal to the saved PID.
-    def stop(signal='SIGINT')
-      if running?
-        begin 
-          pid = self.pid
-          if pid
-            Process.kill(signal, pid) if pid != $$
-            delete_pid
-          else
-            raise "Failed to stop: no PID found."
-          end
-        rescue
-          delete_pid
-          raise "Failed to stop: process already stopped; deleted PID file."
-        end
+    # from this script, sends kill signals to the saved PID using pid_end.
+    # Returns true if the process was killed or false otherwise.
+    def stop(signals=%w(SIGTERM SIGQUIT SIGKILL), secs_between_signal=4)
+      return false unless pid_exists?
+      unless running?
+        delete_pid
+        return true
       end
+      pid = self.pid
+      killed = true
+      killed = pid_end(signals, secs_between_signal) if pid != $$
+      delete_pid if killed == true
+      killed
     end
+    
+    # Sends each kill signal to the saved PID, pausing for secs_between_signal
+    # after each to check if it the process remains running.  Stops when the
+    # process has ended or when all signals have been tried.  Returns true if
+    # the process was killed or false otherwise.
+    def pid_end(signals=%w(SIGTERM SIGQUIT SIGKILL), secs_between_signal=4)
+      pid = self.pid
+      signals = [ signals ].flatten.map{|sig| sig.to_s}
+      existed = false
+      signals.each do |sig|
+        begin
+          Process.kill(sig, pid)
+          existed = true
+        rescue Errno::ESRCH
+          return (existed ? true : nil)
+        end
+        return true unless running?
+        sleep secs_between_signal
+        return true unless running?
+      end
+      not running?
+    end 
   end
 end

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: pidify
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 date: 2006-01-10 00:00:00 -05:00
 summary: This allows a script to check if there is currently another running instance of itself, and give it the ability to kill that instance based on PID.
 require_paths: