daemons 1.1.9 → 1.2.1

data/lib/daemons/pid.rb

@@ -1,12 +1,10 @@
-
+require 'daemons/exceptions'
 
 module Daemons
-
   class Pid
-  
-    def Pid.running?(pid)
+    def self.running?(pid)
       return false unless pid
-      
+
       # Check if process is in existence
       # The simplest way to do this is to send signal '0'
       # (which is a single system call) that doesn't actually
@@ -14,95 +12,65 @@ module Daemons
       begin
         Process.kill(0, pid)
         return true
+      rescue TimeoutError
+        raise
       rescue Errno::ESRCH
         return false
       rescue ::Exception   # for example on EPERM (process exists but does not belong to us)
         return true
-      #rescue Errno::EPERM
+      # rescue Errno::EPERM
       #  return false
       end
     end
-    
-  #  def Pid.running?(pid, additional = nil)
-  #    match_pid = Regexp.new("^\\s*#{pid}\\s")
-  #    got_match = false
-  #
-  #    #ps_all = IO.popen('ps ax') # the correct syntax is without a dash (-) !
-  #    ps_in, ps_out, ps_err = Open3.popen3('ps ax') # the correct syntax is without a dash (-) !
-  #    
-  #    return true unless ps_out.gets
-  #    
-  #    begin
-  #      ps_out.each { |psline|
-  #        next unless psline =~ match_pid
-  #        got_match = true
-  #        got_match = false if additional and psline !~ /#{additional}/
-  #        break
-  #      }
-  #    ensure
-  #      begin; begin; ps_in.close; rescue ::Exception; end; begin; ps_out.close; rescue ::Exception; end; ps_err.close; rescue ::Exception; end
-  #    end
-  #    
-  #    # an alternative would be to use the code below, but I don't know whether this is portable
-  #    # `ps axo pid=`.split.include? pid.to_s
-  #     
-  #    return got_match
-  #  end
-    
-    
-    
+
     # Returns the directory that should be used to write the pid file to
     # depending on the given mode.
-    # 
-    # Some modes may require an additionaly hint, others may determine 
+    #
+    # Some modes may require an additionaly hint, others may determine
     # the directory automatically.
     #
     # If no valid directory is found, returns nil.
     #
-    def Pid.dir(dir_mode, dir, script)
+    def self.dir(dir_mode, dir, script)
       # nil script parameter is allowed as long as dir_mode is not :script
-      return nil if dir_mode == :script && script.nil?                         
-      
+      return nil if dir_mode == :script && script.nil?
+
       case dir_mode
         when :normal
           return File.expand_path(dir)
         when :script
-          return File.expand_path(File.join(File.dirname(script),dir))
-        when :system  
+          return File.expand_path(File.join(File.dirname(script), dir))
+        when :system
           return '/var/run'
         else
-          raise Error.new("pid file mode '#{dir_mode}' not implemented")
+          fail Error.new("pid file mode '#{dir_mode}' not implemented")
       end
     end
-    
+
     # Initialization method
     def initialize
     end
-    
-    
+
     # Get method
     def pid
     end
-    
+
     # Set method
     def pid=(p)
     end
-    
+
     # Check whether the process is running
     def running?
-      return Pid.running?(pid())
+      Pid.running?(pid)
     end
-    
+
     # Cleanup method
     def cleanup
     end
-    
+
     # Exist? method
     def exist?
       true
     end
-    
-  end  
-  
-  
-end
+  end
+end

data/lib/daemons/pidfile.rb

@@ -1,8 +1,6 @@
 require 'daemons/pid'
 
-
 module Daemons
-
   # === What is a Pid-File?
   # A <i>Pid-File</i> is a file containing the <i>process identification number</i>
   # (pid) that is stored in a well-defined location of the filesystem thus allowing other
@@ -20,9 +18,9 @@ module Daemons
   # run at any time)
   #
   # Each file just contains one line with the pid as string (for example <tt>6432</tt>).
-  #  
+  #
   # === Where are the Pid-Files stored?
-  # 
+  #
   # Daemons is configurable to store the Pid-Files relative to three different locations:
   # 1.  in a directory relative to the directory where the script (the one that is supposed to run
   #     as a daemon) resides (<tt>:script</tt> option for <tt>:dir_mode</tt>)
@@ -30,17 +28,17 @@ module Daemons
   # 3.  in the preconfigured directory <tt>/var/run</tt> (<tt>:system</tt> option for <tt>:dir_mode</tt>)
   #
   class PidFile < Pid
-
     attr_reader :dir, :progname, :multiple, :number
 
-    def PidFile.find_files(dir, progname, delete = false)
-      files = Dir[File.join(dir, "#{progname}*.pid")]
-      
-      files.delete_if {|f| not (File.file?(f) and File.readable?(f))}
-      if delete 
+    def self.find_files(dir, progname, delete = false)
+      files = Dir[File.join(dir, "#{progname}_num*.pid")]
+      files = Dir[File.join(dir, "#{progname}.pid")] if files.size == 0
+
+      files.delete_if { |f| not (File.file?(f) and File.readable?(f)) }
+      if delete
         files.delete_if do |f|
-          pid = File.open(f) {|h| h.read}.to_i
-          rsl =  ! Pid.running?(pid)
+          pid = File.open(f) { |h| h.read }.to_i
+          rsl =  !Pid.running?(pid)
           if rsl
             puts "pid-file for killed process #{pid} found (#{f}), deleting."
             begin; File.unlink(f); rescue ::Exception; end
@@ -48,53 +46,53 @@ module Daemons
           rsl
         end
       end
-    
-      return files
+
+      files
     end
-    
-    def PidFile.existing(path)
+
+    def self.existing(path)
       new_instance = PidFile.allocate
-      
+
       new_instance.instance_variable_set(:@path, path)
-      
+
       def new_instance.filename
-        return @path
+        @path
       end
-      
-      return new_instance
+
+      new_instance
     end
-    
+
     def initialize(dir, progname, multiple = false)
       @dir = File.expand_path(dir)
       @progname = progname
       @multiple = multiple
       @number = nil
       @number = 0 if multiple
-      
+
       if multiple
-        while File.exist?(filename) and @number < 1024
+        while File.exist?(filename) && @number < 1024
           @number += 1
         end
-        
-        if @number == 1024
-          raise RuntimeException('cannot run more than 1024 instances of the application')
+
+        if @number >= 1024
+          fail RuntimeException('cannot run more than 1024 instances of the application')
         end
       end
     end
-    
+
     def filename
-      File.join(@dir, "#{@progname}#{ @number or '' }.pid")
+      File.join(@dir, "#{@progname}#{@number ? '_num' + @number.to_s : '' }.pid")
     end
-    
+
     def exist?
       File.exist? filename
     end
-    
+
     def pid=(p)
-      File.open(filename, 'w') {|f|
+      File.open(filename, 'w') do |f|
         f.chmod(0644)
-        f.puts p   #Process.pid
-      }
+        f.puts p   # Process.pid
+      end
     end
 
     def cleanup
@@ -103,14 +101,14 @@ module Daemons
 
     def pid
       begin
-        File.open(filename) {|f|
-          return f.gets.to_i
-        }
+        File.open(filename) do |f|
+          p = f.gets.to_i
+          return nil if p == 0 # Otherwise an invalid pid file becomes pid 0
+          return p
+        end
       rescue ::Exception
         return nil
       end
     end
-
   end
-  
-end
+end

data/lib/daemons/pidmem.rb

@@ -1,19 +1,15 @@
 require 'daemons/pid'
 
-
 module Daemons
-
   class PidMem < Pid
     attr_accessor :pid
-    
-    def PidMem.existing(numeric_pid)
+
+    def self.existing(numeric_pid)
       new_instance = PidMem.allocate
-      
+
       new_instance.instance_variable_set(:@pid, numeric_pid)
-      
-      return new_instance
+
+      new_instance
     end
-    
   end
-
 end

data/lib/daemons/version.rb

@@ -0,0 +1,3 @@
+module Daemons
+  VERSION = '1.2.1'
+end

metadata

@@ -1,56 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: daemons
 version: !ruby/object:Gem::Version
-  version: 1.1.9
-  prerelease: 
+  version: 1.2.1
 platform: ruby
 authors:
 - Thomas Uehlinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-10 00:00:00.000000000 Z
+date: 2015-03-08 00:00:00.000000000 Z
 dependencies: []
-description: Daemons provides an easy way to wrap existing ruby scripts (for example
-  a self-written server)  to be run as a daemon and to be controlled by simple start/stop/restart
-  commands.  You can also call blocks as daemons and control them from the parent
-  or just daemonize the current process.  Besides this basic functionality, daemons
-  offers many advanced features like exception  backtracing and logging (in case your
-  ruby script crashes) and monitoring and automatic restarting of your processes if
-  they crash.
-email: th.uehlinger@gmx.ch
+description: |2
+      Daemons provides an easy way to wrap existing ruby scripts (for example a
+      self-written server)  to be run as a daemon and to be controlled by simple
+      start/stop/restart commands.
+
+      You can also call blocks as daemons and control them from the parent or just
+      daemonize the current process.
+
+      Besides this basic functionality, daemons offers many advanced features like
+      exception backtracing and logging (in case your ruby script crashes) and
+      monitoring and automatic restarting of your processes if they crash.
+email: thomas.uehinger@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README
-- Releases
-- TODO
+extra_rdoc_files: []
 files:
-- Rakefile
-- Releases
-- TODO
-- README
 - LICENSE
-- setup.rb
-- lib/daemons.rb
-- lib/daemons/application.rb
-- lib/daemons/application_group.rb
-- lib/daemons/change_privilege.rb
-- lib/daemons/cmdline.rb
-- lib/daemons/controller.rb
-- lib/daemons/daemonize.rb
-- lib/daemons/etc_extension.rb
-- lib/daemons/exceptions.rb
-- lib/daemons/monitor.rb
-- lib/daemons/pid.rb
-- lib/daemons/pidfile.rb
-- lib/daemons/pidmem.rb
+- README.md
+- Releases
+- examples/call/call.rb
+- examples/call/call_monitor.rb
+- examples/daemonize/daemonize.rb
 - examples/run/ctrl_crash.rb
+- examples/run/ctrl_custom_logfiles.rb
 - examples/run/ctrl_exec.rb
 - examples/run/ctrl_exit.rb
 - examples/run/ctrl_hanging.rb
 - examples/run/ctrl_keep_pid_files.rb
 - examples/run/ctrl_monitor.rb
+- examples/run/ctrl_monitor_multiple.rb
 - examples/run/ctrl_multiple.rb
 - examples/run/ctrl_normal.rb
 - examples/run/ctrl_ontop.rb
@@ -65,31 +54,42 @@ files:
 - examples/run/myserver_exiting.rb
 - examples/run/myserver_hanging.rb
 - examples/run/myserver_slowstop.rb
-- examples/call/call.rb
-- examples/call/call_monitor.rb
-- examples/daemonize/daemonize.rb
-homepage: http://daemons.rubyforge.org
-licenses: []
+- lib/daemons.rb
+- lib/daemons/application.rb
+- lib/daemons/application_group.rb
+- lib/daemons/change_privilege.rb
+- lib/daemons/cmdline.rb
+- lib/daemons/controller.rb
+- lib/daemons/daemonize.rb
+- lib/daemons/etc_extension.rb
+- lib/daemons/exceptions.rb
+- lib/daemons/monitor.rb
+- lib/daemons/pid.rb
+- lib/daemons/pidfile.rb
+- lib/daemons/pidmem.rb
+- lib/daemons/version.rb
+homepage: https://github.com/thuehlinger/daemons
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: daemons
-rubygems_version: 1.8.23
+rubyforge_project: 
+rubygems_version: 2.4.6
 signing_key: 
-specification_version: 2
+specification_version: 4
 summary: A toolkit to create and control daemons in different ways
 test_files: []

data/README

@@ -1,214 +0,0 @@
-= Daemons Version 1.1.9
-
-(See Releases for release-specific information)
-
-== What is Daemons?
-
-Daemons provides an easy way to wrap existing ruby scripts (for example a self-written server) 
-to be <i>run as a daemon</i> and to be <i>controlled by simple start/stop/restart commands</i>.
-
-If you want, you can also use daemons to <i>run blocks of ruby code in a daemon process</i> and to control
-these processes from the main application.
-
-Besides this basic functionality, daemons offers many advanced features like <i>exception backtracing</i> 
-and logging (in case your ruby script crashes) and <i>monitoring</i> and automatic restarting of your processes
-if they crash.
-
-== Basic Usage
-
-You can use Daemons in four different ways:
-
-=== 1. Create wrapper scripts for your server scripts or applications
-
-Layout: suppose you have your self-written server <tt>myserver.rb</tt>:
-
-  # this is myserver.rb
-  # it does nothing really useful at the moment
-  
-  loop do
-    sleep(5)
-  end
-  
-To use <tt>myserver.rb</tt> in a production environment, you need to be able to
-run <tt>myserver.rb</tt> in the _background_ (this means detach it from the console, fork it
-in the background, release all directories and file descriptors).
-
-Just create <tt>myserver_control.rb</tt> like this:
-
-  # this is myserver_control.rb
-  
-  require 'rubygems'        # if you use RubyGems
-  require 'daemons'
-  
-  Daemons.run('myserver.rb')
-  
-And use it like this from the console:
-
-  $ ruby myserver_control.rb start
-      (myserver.rb is now running in the background)
-  $ ruby myserver_control.rb restart
-      (...)
-  $ ruby myserver_control.rb stop
-  
-For testing purposes you can even run <tt>myserver.rb</tt> <i>without forking</i> in the background:
-
-  $ ruby myserver_control.rb run
-
-An additional nice feature of Daemons is that you can pass <i>additional arguments</i> to the script that 
-should be daemonized by seperating them by two _hyphens_:
-  
-  $ ruby myserver_control.rb start -- --file=anyfile --a_switch another_argument
-  
-
-=== 2. Create wrapper scripts that include your server procs
-
-Layout: suppose you have some code you want to run in the background and control that background process
-from a script:
-
-  # this is your code
-  # it does nothing really useful at the moment
-  
-  loop do
-    sleep(5)
-  end
-  
-To run this code as a daemon create <tt>myproc_control.rb</tt> like this and include your code:
-
-  # this is myproc_control.rb
-  
-  require 'rubygems'        # if you use RubyGems
-  require 'daemons'
-  
-  Daemons.run_proc('myproc.rb') do
-    loop do
-      sleep(5)
-    end
-  end
-  
-And use it like this from the console:
-
-  $ ruby myproc_control.rb start
-      (myproc.rb is now running in the background)
-  $ ruby myproc_control.rb restart
-      (...)
-  $ ruby myproc_control.rb stop
-  
-For testing purposes you can even run <tt>myproc.rb</tt> <i>without forking</i> in the background:
-
-  $ ruby myproc_control.rb run
-  
-=== 3. Control a bunch of daemons from another application
-
-Layout: you have an application <tt>my_app.rb</tt> that wants to run a bunch of 
-server tasks as daemon processes.
-
-  # this is my_app.rb
-  
-  require 'rubygems'        # if you use RubyGems
-  require 'daemons'
-  
-  task1 = Daemons.call(:multiple => true) do
-    # first server task
-    
-    loop {
-      conn = accept_conn()
-      serve(conn)
-    }
-  end
-  
-  task2 = Daemons.call do
-    # second server task
-    
-    loop {
-      something_different()
-    }
-  end
-  
-  # the parent process continues to run
-  
-  # we can even control our tasks, for example stop them
-  task1.stop
-  task2.stop
-  
-  exit
-  
-=== 4. Daemonize the currently running process
-
-Layout: you have an application <tt>my_daemon.rb</tt> that wants to run as a daemon
-(but without the ability to be controlled by daemons via start/stop commands)
-
-  # this is my_daemons.rb
-  
-  require 'rubygems'        # if you use RubyGems
-  require 'daemons'
-  
-  # Initialize the app while we're not a daemon
-  init()
-  
-  # Become a daemon
-  Daemons.daemonize
-  
-  # The server loop
-  loop {
-    conn = accept_conn()
-    serve(conn)
-  }
-
-  
-<b>For further documentation, refer to the module documentation of Daemons.</b>
-
-  
-== Download and Installation
-
-*Download*: just go to http://rubyforge.org/projects/daemons/
-
-Installation *with* RubyGems:
-  $ su
-  # gem install daemons
-  
-Installation *without* RubyGems:
-  $ tar xfz daemons-x.x.x.tar.gz
-  $ cd daemons-x.x.x
-  $ su
-  # ruby setup.rb
-  
-== Documentation
-
-For further documentation, refer to the module documentation of Daemons (click on Daemons).
-
-The RDoc documentation is also online at http://daemons.rubyforge.org
-
-
-== Author
-
-Written 2005-2010 by Thomas Uehlinger <mailto:th.uehlinger@gmx.ch>.
-Anonymous SVN checkout is available with "svn checkout http://daemons.rubyforge.org/svn/".
-
-== License
-
-Copyright (c) 2005-2012 Thomas Uehlinger
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-== Feedback and other resources
-
-At http://rubyforge.org/projects/daemons.