daemons 1.1.9 → 1.4.1

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
@@ -15,14 +13,14 @@ module Daemons
   # === How does a Pid-File look like?
   #
   # Pid-Files generated by Daemons have to following format:
-  #   <scriptname>.rb<number>.pid
-  # (Note that <tt><number></tt> is omitted if only one instance of the script can
+  #   <scriptname>_num<number>.pid
+  # (Note that <tt>_num<number></tt> is omitted if only one instance of the script can
   # 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,87 +28,94 @@ module Daemons
   # 3.  in the preconfigured directory <tt>/var/run</tt> (<tt>:system</tt> option for <tt>:dir_mode</tt>)
   #
   class PidFile < Pid
+    DEFAULT_PID_DELIMITER = '_num'
+    attr_reader :dir, :progname, :multiple, :number, :pid_delimiter
 
-    attr_reader :dir, :progname, :multiple, :number
+    def self.find_files(dir, progname, delete = false, pid_delimiter = nil)
+      files = Dir[File.join(dir, "#{progname}#{pid_delimiter || DEFAULT_PID_DELIMITER}*.pid")]
+      files = Dir[File.join(dir, "#{progname}.pid")] if files.size == 0
 
-    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 
+      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
+            yield(pid, f) if block_given?
           end
           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)
+
+    def initialize(dir, progname, multiple = false, pid_delimiter = nil)
       @dir = File.expand_path(dir)
       @progname = progname
       @multiple = multiple
+      @pid_delimiter = pid_delimiter || DEFAULT_PID_DELIMITER
       @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")
+      suffix = "#{pid_delimiter}#{@number}" if @number
+      File.join(@dir, "#{@progname}#{suffix}.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
       File.delete(filename) if pid == Process.pid
     end
 
+    def zap
+      File.delete(filename) if exist?
+    end
+
     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/reporter.rb

@@ -0,0 +1,54 @@
+module Daemons
+  class Reporter
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+
+      if !options[:shush]
+        $stdout.sync = true
+      end
+    end
+
+    def output_message(message)
+      if !options[:shush]
+        puts message
+      end
+    end
+
+    def changing_process_privilege(user, group = user)
+      output_message "Changing process privilege to #{user}:#{group}"
+    end
+
+    def deleted_found_pidfile(pid, f)
+      output_message "pid-file for killed process #{pid} found (#{f}), deleting."
+    end
+
+    def process_started(app_name, pid)
+      output_message  "#{app_name}: process with pid #{pid} started."
+    end
+
+    def backtrace_not_supported 
+      output_message 'option :backtrace is not supported with :mode => :exec, ignoring'
+    end
+
+    def stopping_process(app_name, pid, sig, wait)
+      output_message "#{app_name}: trying to stop process with pid #{pid}#{' forcefully :(' if sig == 'KILL'} sending #{sig} and waiting #{wait}s ..."
+      $stdout.flush
+    end
+
+    def cannot_stop_process(app_name, pid)
+      output_message "#{app_name}: unable to forcefully kill process with pid #{pid}."
+      $stdout.flush
+    end
+
+    def stopped_process(app_name, pid)
+      output_message "#{app_name}: process with pid #{pid} successfully stopped."
+      $stdout.flush
+    end
+
+    def status(app_name, running, pid_exists, pid)
+      output_message "#{app_name}: #{running ? '' : 'not '}running#{(running and pid_exists) ? ' [pid ' + pid.to_s + ']' : ''}#{(pid_exists and not running) ? ' (but pid-file exists: ' + pid.to_s + ')' : ''}"
+    end
+  end
+end

data/lib/daemons/syslogio.rb

@@ -0,0 +1,240 @@
+# This is a simple class meant to allow using syslog through an IO-like object. Code
+# borrowed from https://github.com/phemmer/ruby-syslogio
+#
+# The usage is simple:
+#
+#     require 'syslogio'
+#     $stdout = SyslogIO.new("myapp", :local0, :info, $stdout)
+#     $stderr = SyslogIO.new("myapp", :local0, :err, $stderr)
+#     $stdout.puts "This is a message"
+#     $stderr.puts "This is an error"
+#     raise StandardError, 'This will get written through the SyslogIO for $stderr'
+
+class Daemons::SyslogIO
+  require 'syslog'
+
+  # Indicates whether synchonous IO is enabled.
+  # @return [Boolean]
+  attr_reader :sync
+
+  # @!visibility private
+  def self.syslog_constant_sym(option)
+    return unless option.is_a?(Symbol) or option.is_a?(String)
+    option = option.to_s.upcase
+    option = "LOG_#{option}" unless option[0..4] == 'LOG_'
+    option = option.to_sym
+    option
+  end
+  # @!visibility private
+  def self.syslog_constant(option)
+    return unless option = syslog_constant_sym(option)
+    return Syslog.constants.include?(option) ? Syslog.const_get(option) : nil
+  end
+  # @!visibility private
+  def self.syslog_facility(option)
+    return unless option = syslog_constant_sym(option)
+    return Syslog::Facility.constants.include?(option) ? Syslog.const_get(option) : nil
+  end
+  # @!visibility private
+  def self.syslog_level(option)
+    return unless option = syslog_constant_sym(option)
+    return Syslog::Level.constants.include?(option) ? Syslog.const_get(option) : nil
+  end
+  # @!visibility private
+  def self.syslog_option(option)
+    return unless option = syslog_constant_sym(option)
+    return Syslog::Option.constants.include?(option) ? Syslog.const_get(option) : nil
+  end
+
+  # Creates a new object.
+  # You can have as many SyslogIO objects as you like. However because they all share the same syslog connection, some parameters are shared. The identifier shared among all SyslogIO objects, and is set to the value of the last one created. The Syslog options are merged together as a combination of all objects. The facility and level are distinct between each though.
+  # If an IO object is provided as an argument, any text written to the SyslogIO object will also be passed through to that IO object.
+  #
+  # @param identifier [String] Identifier
+  # @param facility [Fixnum<Syslog::Facility>] Syslog facility
+  # @param level [Fixnum<Syslog::Level>] Syslog level
+  # @param option [Fixnum<Syslog::Options>] Syslog option
+  # @param passthrough [IO] IO passthrough
+  def initialize(*options)
+    options.each do |option|
+      if option.is_a?(String)
+        @ident = option
+      elsif value = self.class.syslog_facility(option)
+        @facility = value
+      elsif value = self.class.syslog_level(option)
+        @level = value
+      elsif value = self.class.syslog_option(option)
+        @options = 0 if @options.nil?
+        @options |= value
+      elsif option.is_a?(IO)
+        @out = option
+      else
+        raise ArgumentError, "Unknown argument #{option.inspect}"
+      end
+    end
+
+    @options ||= 0
+    @ident ||= $0.sub(/.*\//, '')
+    @facility ||= Syslog::LOG_USER
+    @level ||= Syslog::LOG_INFO
+
+    if Syslog.opened? then
+      options = Syslog.options | @options
+      @syslog = Syslog.reopen(@ident, options, @facility)
+    else
+      @syslog = Syslog.open(@ident, @options, @facility)
+    end
+
+    @subs = []
+    @sync = false
+    @buffer = ''
+
+    at_exit { flush }
+  end
+
+  # Add a substitution rule
+  #
+  # These substitutions will be applied to each line before it is logged. This can be useful if some other gem is generating log content and you want to change the formatting.
+  # @param regex [Regex]
+  def sub_add(regex, replacement)
+    @subs << [regex, replacement]
+  end
+
+  # Enable or disable synchronous IO (buffering).
+  #
+  # When false (default), output will be line buffered. For syslog this is optimal so the log entries are complete lines.
+  def sync=(sync)
+    if sync != true and sync != false then
+      raise ArgumentError, "sync must be true or false"
+    end
+    @sync = sync
+    if sync == true then
+      flush
+    end
+  end
+
+  # Write to syslog respecting the behavior of the {#sync} setting.
+  def write(text)
+    if @sync then
+      syswrite(text)
+    else
+      text.split(/(\n)/).each do |line|
+        @buffer = @buffer + line.to_s
+        if line == "\n" then
+          flush
+        end
+      end
+    end
+  end
+  alias_method :<<, :write
+
+  # Write to syslog directly, bypassing buffering if enabled.
+  def syswrite(text)
+    begin
+      @out.syswrite(text) if @out and !@out.closed?
+    rescue SystemCallError => e
+    end
+
+    text.split(/\n/).each do |line|
+      @subs.each do |sub|
+        line.sub!(sub[0], sub[1])
+      end
+      if line == '' or line.match(/^\s*$/) then
+        next
+      end
+      Syslog.log(@facility | @level, line)
+    end
+    nil
+  end
+
+  # Immediately flush any buffered data
+  def flush
+    syswrite(@buffer)
+    @buffer = ''
+  end
+
+  # Log at the debug level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_DEBUG)
+  def debug(text)
+    log(text, Syslog::LOG_DEBUG)
+  end
+
+  # Log at the info level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_INFO)
+  def info(text)
+    log(text, Syslog::LOG_INFO)
+  end
+
+  # Log at the notice level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_NOTICE)
+  def notice(text)
+    log(text, Syslog::LOG_NOTICE)
+  end
+  alias_method :notify, :notice
+
+  # Log at the warning level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_WARNING)
+  def warn(text)
+    log(text, Syslog::LOG_WARNING)
+  end
+
+  # Log at the error level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_ERR)
+  def error(text)
+    log(text, Syslog::LOG_ERR)
+  end
+
+  # Log at the critical level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_CRIT)
+  def crit(text)
+    log(text, Syslog::LOG_CRIT)
+  end
+  alias_method :fatal, :crit
+
+  # Log at the emergency level
+  #
+  # Shorthand for {#log}(text, Syslog::LOG_EMERG)
+  def emerg(text)
+    log(text, Syslog::LOG_EMERG)
+  end
+
+  # Log a complete line
+  #
+  # Similar to {#write} but appends a newline if not present.
+  def puts(*texts)
+    texts.each do |text|
+      write(text.chomp + "\n")
+    end
+  end
+
+  # Write a complete line at the specified log level
+  #
+  # Similar to {#puts} but allows changing the log level for just this one message
+  def log(text, level = nil)
+    if priority.nil? then
+      write(text.chomp + "\n")
+    else
+      priority_bkup = @priority
+      #TODO fix this to be less ugly. Temporarily setting an instance variable is evil
+      @priority = priority
+      write(text.chomp + "\n")
+      @priority = priority_bkup
+    end
+  end
+
+  # @!visibility private
+  def noop(*args)
+  end
+  alias_method :reopen, :noop
+
+  # false
+  def isatty
+    false
+  end
+end

data/lib/daemons/version.rb

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