resurrected_god 0.14.0 → 1.0.0

data/lib/god/process.rb

@@ -1,6 +1,6 @@
 module God
   class Process
-    WRITES_PID = [:start, :restart]
+    WRITES_PID = [:start, :restart].freeze
 
     attr_accessor :name, :uid, :gid, :log, :log_cmd, :err_log, :err_log_cmd,
                   :start, :stop, :restart, :unix_socket, :chroot, :env, :dir,
@@ -20,8 +20,8 @@ module God
     end
 
     def alive?
-      if self.pid
-        System::Process.new(self.pid).exists?
+      if pid
+        System::Process.new(pid).exists?
       else
         false
       end
@@ -30,21 +30,21 @@ module God
     def file_writable?(file)
       pid = fork do
         begin
-          if self.uid
-            user_method = self.uid.is_a?(Integer) ? :getpwuid : :getpwnam
-            uid_num = Etc.send(user_method, self.uid).uid
-            gid_num = Etc.send(user_method, self.uid).gid
+          if uid
+            user_method = uid.is_a?(Integer) ? :getpwuid : :getpwnam
+            uid_num = Etc.send(user_method, uid).uid
+            gid_num = Etc.send(user_method, uid).gid
           end
-          if self.gid
-            group_method = self.gid.is_a?(Integer) ? :getgrgid : :getgrnam
-            gid_num = Etc.send(group_method, self.gid).gid
+          if gid
+            group_method = gid.is_a?(Integer) ? :getgrgid : :getgrnam
+            gid_num = Etc.send(group_method, gid).gid
           end
 
-          ::Dir.chroot(self.chroot) if self.chroot
+          ::Dir.chroot(chroot) if chroot
           ::Process.groups = [gid_num] if gid_num
-          ::Process.initgroups(self.uid, gid_num) if self.uid && gid_num
+          ::Process.initgroups(uid, gid_num) if uid && gid_num
           ::Process::Sys.setgid(gid_num) if gid_num
-          ::Process::Sys.setuid(uid_num) if self.uid
+          ::Process::Sys.setuid(uid_num) if uid
         rescue ArgumentError, Errno::EPERM, Errno::ENOENT
           exit(1)
         end
@@ -52,94 +52,94 @@ module God
         File.writable?(file_in_chroot(file)) ? exit!(0) : exit!(1)
       end
 
-      wpid, status = ::Process.waitpid2(pid)
-      status.exitstatus == 0 ? true : false
+      _wpid, status = ::Process.waitpid2(pid)
+      status.exitstatus == 0
     end
 
     def valid?
       # determine if we're tracking pid or not
-      self.pid_file
+      pid_file
 
       valid = true
 
       # a start command must be specified
-      if self.start.nil?
+      if start.nil?
         valid = false
-        applog(self, :error, "No start command was specified")
+        applog(self, :error, 'No start command was specified')
       end
 
       # uid must exist if specified
-      if self.uid
+      if uid
         begin
-          Etc.getpwnam(self.uid)
+          Etc.getpwnam(uid)
         rescue ArgumentError
           valid = false
-          applog(self, :error, "UID for '#{self.uid}' does not exist")
+          applog(self, :error, "UID for '#{uid}' does not exist")
         end
       end
 
       # gid must exist if specified
-      if self.gid
+      if gid
         begin
-          Etc.getgrnam(self.gid)
+          Etc.getgrnam(gid)
         rescue ArgumentError
           valid = false
-          applog(self, :error, "GID for '#{self.gid}' does not exist")
+          applog(self, :error, "GID for '#{gid}' does not exist")
         end
       end
 
       # dir must exist and be a directory if specified
-      if self.dir
-        if !File.exist?(self.dir)
+      if dir
+        if !File.exist?(dir)
           valid = false
-          applog(self, :error, "Specified directory '#{self.dir}' does not exist")
-        elsif !File.directory?(self.dir)
+          applog(self, :error, "Specified directory '#{dir}' does not exist")
+        elsif !File.directory?(dir)
           valid = false
-          applog(self, :error, "Specified directory '#{self.dir}' is not a directory")
+          applog(self, :error, "Specified directory '#{dir}' is not a directory")
         end
       end
 
       # pid dir must exist if specified
-      if !@tracking_pid && !File.exist?(File.dirname(self.pid_file))
+      if !@tracking_pid && !File.exist?(File.dirname(pid_file))
         valid = false
-        applog(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' does not exist")
+        applog(self, :error, "PID file directory '#{File.dirname(pid_file)}' does not exist")
       end
 
       # pid dir must be writable if specified
-      if !@tracking_pid && File.exist?(File.dirname(self.pid_file)) && !file_writable?(File.dirname(self.pid_file))
+      if !@tracking_pid && File.exist?(File.dirname(pid_file)) && !file_writable?(File.dirname(pid_file))
         valid = false
-        applog(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' is not writable by #{self.uid || Etc.getlogin}")
+        applog(self, :error, "PID file directory '#{File.dirname(pid_file)}' is not writable by #{uid || Etc.getlogin}")
       end
 
       # log dir must exist
-      if !File.exist?(File.dirname(self.log))
+      unless File.exist?(File.dirname(log))
         valid = false
-        applog(self, :error, "Log directory '#{File.dirname(self.log)}' does not exist")
+        applog(self, :error, "Log directory '#{File.dirname(log)}' does not exist")
       end
 
       # log file or dir must be writable
-      if File.exist?(self.log)
-        unless file_writable?(self.log)
+      if File.exist?(log)
+        unless file_writable?(log)
           valid = false
-          applog(self, :error, "Log file '#{self.log}' exists but is not writable by #{self.uid || Etc.getlogin}")
+          applog(self, :error, "Log file '#{log}' exists but is not writable by #{uid || Etc.getlogin}")
         end
       else
-        unless file_writable?(File.dirname(self.log))
+        unless file_writable?(File.dirname(log))
           valid = false
-          applog(self, :error, "Log directory '#{File.dirname(self.log)}' is not writable by #{self.uid || Etc.getlogin}")
+          applog(self, :error, "Log directory '#{File.dirname(log)}' is not writable by #{uid || Etc.getlogin}")
         end
       end
 
       # chroot directory must exist and have /dev/null in it
-      if self.chroot
-        if !File.directory?(self.chroot)
+      if chroot
+        unless File.directory?(chroot)
           valid = false
-          applog(self, :error, "CHROOT directory '#{self.chroot}' does not exist")
+          applog(self, :error, "CHROOT directory '#{chroot}' does not exist")
         end
 
-        if !File.exist?(File.join(self.chroot, '/dev/null'))
+        unless File.exist?(File.join(chroot, '/dev/null'))
           valid = false
-          applog(self, :error, "CHROOT directory '#{self.chroot}' does not contain '/dev/null'")
+          applog(self, :error, "CHROOT directory '#{chroot}' does not contain '/dev/null'")
         end
       end
 
@@ -150,11 +150,11 @@ module God
     # No really, trust me. Use the instance variable.
     def pid_file=(value)
       # if value is nil, do the right thing
-      if value
-        @tracking_pid = false
-      else
-        @tracking_pid = true
-      end
+      @tracking_pid = if value
+                        false
+                      else
+                        true
+                      end
 
       @pid_file = value
     end
@@ -169,8 +169,8 @@ module God
     #
     # Returns Integer(pid) or nil
     def pid
-      contents = File.read(self.pid_file).strip rescue ''
-      real_pid = contents =~ /^\d+$/ ? contents.to_i : nil
+      contents = File.read(pid_file).strip rescue ''
+      real_pid = /^\d+$/.match?(contents) ? contents.to_i : nil
 
       if real_pid
         @pid = real_pid
@@ -185,8 +185,8 @@ module God
     # Returns nothing
     def signal(sig)
       sig = sig.to_i if sig.to_i != 0
-      applog(self, :info, "#{self.name} sending signal '#{sig}' to pid #{self.pid}")
-      ::Process.kill(sig, self.pid) rescue nil
+      applog(self, :info, "#{name} sending signal '#{sig}' to pid #{pid}")
+      ::Process.kill(sig, pid) rescue nil
     end
 
     def start!
@@ -202,7 +202,7 @@ module God
     end
 
     def default_pid_file
-      File.join(God.pid_file_directory, "#{self.name}.pid")
+      File.join(God.pid_file_directory, "#{name}.pid")
     end
 
     def call_action(action)
@@ -210,12 +210,11 @@ module God
 
       if action == :stop && command.nil?
         pid = self.pid
-        name = self.name
         command = lambda do
-          applog(self, :info, "#{self.name} stop: default lambda killer")
+          applog(self, :info, "#{name} stop: default lambda killer")
 
           ::Process.kill(@stop_signal, pid) rescue nil
-          applog(self, :info, "#{self.name} sent SIG#{@stop_signal}")
+          applog(self, :info, "#{name} sent SIG#{@stop_signal}")
 
           # Poll to see if it's dead
           pid_not_found = false
@@ -225,11 +224,11 @@ module God
                 ::Process.kill(0, pid)
               rescue Errno::ESRCH
                 # It died. Good.
-                applog(self, :info, "#{self.name} process stopped")
+                applog(self, :info, "#{name} process stopped")
                 return
               end
             else
-              applog(self, :warn, "#{self.name} pid not found in #{self.pid_file}") unless pid_not_found
+              applog(self, :warn, "#{name} pid not found in #{pid_file}") unless pid_not_found
               pid_not_found = true
             end
 
@@ -237,20 +236,19 @@ module God
           end
 
           ::Process.kill('KILL', pid) rescue nil
-          applog(self, :warn, "#{self.name} still alive after #{@stop_timeout}s; sent SIGKILL")
+          applog(self, :warn, "#{name} still alive after #{@stop_timeout}s; sent SIGKILL")
         end
       end
 
-      if command.kind_of?(String)
-        pid = nil
-
+      case command
+      when String
         if [:start, :restart].include?(action) && @tracking_pid
           # double fork god-daemonized processes
           # we don't want to wait for them to finish
           r, w = IO.pipe
           begin
             opid = fork do
-              STDOUT.reopen(w)
+              $stdout.reopen(w)
               r.close
               pid = self.spawn(command)
               puts pid.to_s # send pid back to forker
@@ -272,22 +270,18 @@ module God
           status = ::Process.waitpid2(pid, 0)
           exit_code = status[1] >> 8
 
-          if exit_code != 0
-            applog(self, :warn, "#{self.name} #{action} command exited with non-zero code = #{exit_code}")
-          end
+          applog(self, :warn, "#{name} #{action} command exited with non-zero code = #{exit_code}") if exit_code != 0
 
           ensure_stop if action == :stop
         end
 
-        if @tracking_pid or (@pid_file.nil? and WRITES_PID.include?(action))
-          File.open(default_pid_file, 'w') do |f|
-            f.write pid
-          end
+        if @tracking_pid || (@pid_file.nil? && WRITES_PID.include?(action))
+          File.write(default_pid_file, pid)
 
           @tracking_pid = true
           @pid_file = default_pid_file
         end
-      elsif command.kind_of?(Proc)
+      when Proc
         # lambda command
         command.call
       else
@@ -301,39 +295,39 @@ module God
     # Returns nothing
     def spawn(command)
       fork do
-        File.umask self.umask if self.umask
-        uid_num = Etc.getpwnam(self.uid).uid if self.uid
-        gid_num = Etc.getgrnam(self.gid).gid if self.gid
-        gid_num = Etc.getpwnam(self.uid).gid if self.gid.nil? && self.uid
+        File.umask umask if umask
+        uid_num = Etc.getpwnam(uid).uid if uid
+        gid_num = Etc.getgrnam(gid).gid if gid
+        gid_num = Etc.getpwnam(uid).gid if gid.nil? && uid
 
-        ::Dir.chroot(self.chroot) if self.chroot
+        ::Dir.chroot(chroot) if chroot
         ::Process.setsid
         ::Process.groups = [gid_num] if gid_num
-        ::Process.initgroups(self.uid, gid_num) if self.uid && gid_num
+        ::Process.initgroups(uid, gid_num) if uid && gid_num
         ::Process::Sys.setgid(gid_num) if gid_num
-        ::Process::Sys.setuid(uid_num) if self.uid
+        ::Process::Sys.setuid(uid_num) if uid
         self.dir ||= '/'
         Dir.chdir self.dir
         $0 = command
-        STDIN.reopen "/dev/null"
-        if self.log_cmd
-          STDOUT.reopen IO.popen(self.log_cmd, "a")
+        $stdin.reopen '/dev/null'
+        if log_cmd
+          $stdout.reopen IO.popen(log_cmd, 'a')
         else
-          STDOUT.reopen file_in_chroot(self.log), "a"
+          $stdout.reopen file_in_chroot(log), 'a'
         end
         if err_log_cmd
-          STDERR.reopen IO.popen(err_log_cmd, "a")
+          $stderr.reopen IO.popen(err_log_cmd, 'a')
         elsif err_log && (log_cmd || err_log != log)
-          STDERR.reopen file_in_chroot(err_log), "a"
+          $stderr.reopen file_in_chroot(err_log), 'a'
         else
-          STDERR.reopen STDOUT
+          $stderr.reopen $stdout
         end
 
         # close any other file descriptors
-        3.upto(256){|fd| IO::new(fd).close rescue nil}
+        3.upto(256) { |fd| IO.new(fd).close rescue nil }
 
-        if self.env && self.env.is_a?(Hash)
-          self.env.each do |(key, value)|
+        if env.is_a?(Hash)
+          env.each do |(key, value)|
             ENV[key] = value.to_s
           end
         end
@@ -347,17 +341,17 @@ module God
     #
     # Returns nothing
     def ensure_stop
-      applog(self, :warn, "#{self.name} ensuring stop...")
+      applog(self, :warn, "#{name} ensuring stop...")
 
-      unless self.pid
-        applog(self, :warn, "#{self.name} stop called but pid is uknown")
+      unless pid
+        applog(self, :warn, "#{name} stop called but pid is uknown")
         return
       end
 
       # Poll to see if it's dead
       @stop_timeout.times do
         begin
-          ::Process.kill(0, self.pid)
+          ::Process.kill(0, pid)
         rescue Errno::ESRCH
           # It died. Good.
           return
@@ -367,15 +361,16 @@ module God
       end
 
       # last resort
-      ::Process.kill('KILL', self.pid) rescue nil
-      applog(self, :warn, "#{self.name} still alive after #{@stop_timeout}s; sent SIGKILL")
+      ::Process.kill('KILL', pid) rescue nil
+      applog(self, :warn, "#{name} still alive after #{@stop_timeout}s; sent SIGKILL")
     end
 
     private
+
     def file_in_chroot(file)
-      return file unless self.chroot
+      return file unless chroot
 
-      file.gsub(/^#{Regexp.escape(File.expand_path(self.chroot))}/, '')
+      file.gsub(/^#{Regexp.escape(File.expand_path(chroot))}/, '')
     end
   end
 end

data/lib/god/simple_logger.rb

@@ -1,5 +1,4 @@
 module God
-
   class SimpleLogger
     DEBUG = 2
     INFO = 4
@@ -7,53 +6,52 @@ module God
     ERROR = 16
     FATAL = 32
 
-    SEV_LABEL = {DEBUG => 'DEBUG',
-                 INFO => 'INFO',
-                 WARN => 'WARN',
-                 ERROR => 'ERROR',
-                 FATAL => 'FATAL'}
+    SEV_LABEL = { DEBUG => 'DEBUG',
+                  INFO => 'INFO',
+                  WARN => 'WARN',
+                  ERROR => 'ERROR',
+                  FATAL => 'FATAL' }.freeze
 
     CONSTANT_TO_SYMBOL = { DEBUG => :debug,
                            INFO => :info,
                            WARN => :warn,
                            ERROR => :error,
-                           FATAL => :fatal }
+                           FATAL => :fatal }.freeze
 
     attr_accessor :datetime_format, :level
 
     def initialize(io)
       @io = io
       @level = INFO
-      @datetime_format = "%Y-%m-%d %H:%M:%S"
+      @datetime_format = '%Y-%m-%d %H:%M:%S'
     end
 
     def output(level, msg)
       return if level < self.level
 
-      time = Time.now.strftime(self.datetime_format)
+      time = Time.now.strftime(datetime_format)
       label = SEV_LABEL[level]
       @io.print("#{label[0..0]} [#{time}] #{label.rjust(5)}: #{msg}\n")
     end
 
     def fatal(msg)
-      self.output(FATAL, msg)
+      output(FATAL, msg)
     end
 
     def error(msg)
-      self.output(ERROR, msg)
+      output(ERROR, msg)
     end
 
     def warn(msg)
-      self.output(WARN, msg)
+      output(WARN, msg)
     end
 
     def info(msg)
-      self.output(INFO, msg)
+      output(INFO, msg)
     end
 
     def debug(msg)
-      self.output(DEBUG, msg)
+      output(DEBUG, msg)
     end
   end
-
 end

data/lib/god/socket.rb

@@ -1,7 +1,6 @@
 require 'drb'
 
 module God
-
   # The God::Server oversees the DRb server which dishes out info on this God daemon.
   class Socket
     attr_reader :port
@@ -19,7 +18,7 @@ module God
     #
     # Returns String (drb address)
     def self.socket(port)
-      "drbunix://#{self.socket_file(port)}"
+      "drbunix://#{socket_file(port)}"
     end
 
     # The location of the socket for this Server
@@ -63,7 +62,7 @@ module God
     # Returns nothing
     def stop
       DRb.stop_service
-      FileUtils.rm_f(self.socket_file)
+      FileUtils.rm_f(socket_file)
     end
 
     private
@@ -74,40 +73,39 @@ module God
     # Returns nothing
     def start
       begin
-        @drb ||= DRb.start_service(self.socket, self)
+        @drb ||= DRb.start_service(socket, self)
         applog(nil, :info, "Started on #{DRb.uri}")
       rescue Errno::EADDRINUSE
-        applog(nil, :info, "Socket already in use")
-        server = DRbObject.new(nil, self.socket)
+        applog(nil, :info, 'Socket already in use')
+        server = DRbObject.new(nil, socket)
 
         begin
           Timeout.timeout(5) do
             server.ping
           end
-          abort "Socket #{self.socket} already in use by another instance of god"
+          abort "Socket #{socket} already in use by another instance of god"
         rescue StandardError, Timeout::Error
-          applog(nil, :info, "Socket is stale, reopening")
-          File.delete(self.socket_file) rescue nil
-          @drb ||= DRb.start_service(self.socket, self)
+          applog(nil, :info, 'Socket is stale, reopening')
+          File.delete(socket_file) rescue nil
+          @drb ||= DRb.start_service(socket, self)
           applog(nil, :info, "Started on #{DRb.uri}")
         end
       end
 
-      if File.exists?(self.socket_file)
-        if @user
-          user_method = @user.is_a?(Integer) ? :getpwuid : :getpwnam
-          uid = Etc.send(user_method, @user).uid
-          gid = Etc.send(user_method, @user).gid
-        end
-        if @group
-          group_method = @group.is_a?(Integer) ? :getgrgid : :getgrnam
-          gid = Etc.send(group_method, @group).gid
-        end
+      return unless File.exist?(socket_file)
 
-        File.chmod(Integer(@perm), socket_file) if @perm
-        File.chown(uid, gid, socket_file) if uid or gid
+      if @user
+        user_method = @user.is_a?(Integer) ? :getpwuid : :getpwnam
+        uid = Etc.send(user_method, @user).uid
+        gid = Etc.send(user_method, @user).gid
       end
+      if @group
+        group_method = @group.is_a?(Integer) ? :getgrgid : :getgrnam
+        gid = Etc.send(group_method, @group).gid
+      end
+
+      File.chmod(Integer(@perm), socket_file) if @perm
+      File.chown(uid, gid, socket_file) if uid || gid
     end
   end
-
 end

data/lib/god/sugar.rb

@@ -5,7 +5,7 @@ class Numeric
   end
 
   # Public: Units of seconds.
-  alias :second :seconds
+  alias second seconds
 
   # Public: Units of minutes (60 seconds).
   def minutes
@@ -13,7 +13,7 @@ class Numeric
   end
 
   # Public: Units of minutes (60 seconds).
-  alias :minute :minutes
+  alias minute minutes
 
   # Public: Units of hours (3600 seconds).
   def hours
@@ -21,7 +21,7 @@ class Numeric
   end
 
   # Public: Units of hours (3600 seconds).
-  alias :hour :hours
+  alias hour hours
 
   # Public: Units of days (86400 seconds).
   def days
@@ -29,7 +29,7 @@ class Numeric
   end
 
   # Public: Units of days (86400 seconds).
-  alias :day :days
+  alias day days
 
   # Units of kilobytes.
   def kilobytes
@@ -37,7 +37,7 @@ class Numeric
   end
 
   # Units of kilobytes.
-  alias :kilobyte :kilobytes
+  alias kilobyte kilobytes
 
   # Units of megabytes (1024 kilobytes).
   def megabytes
@@ -45,15 +45,15 @@ class Numeric
   end
 
   # Units of megabytes (1024 kilobytes).
-  alias :megabyte :megabytes
+  alias megabyte megabytes
 
   # Units of gigabytes (1,048,576 kilobytes).
   def gigabytes
-    self * (1024 ** 2)
+    self * (1024**2)
   end
 
   # Units of gigabytes (1,048,576 kilobytes).
-  alias :gigabyte :gigabytes
+  alias gigabyte gigabytes
 
   # Units of percent. e.g. 50.percent.
   def percent

data/lib/god/sys_logger.rb

@@ -8,16 +8,15 @@ begin
     Syslog.reopen('god')
   end
 
-  Syslog.info("Syslog enabled.")
+  Syslog.info('Syslog enabled.')
 
   module God
-
     class SysLogger
-      SYMBOL_EQUIVALENTS = { :fatal => Syslog::LOG_CRIT,
-                             :error => Syslog::LOG_ERR,
-                             :warn => Syslog::LOG_WARNING,
-                             :info => Syslog::LOG_INFO,
-                             :debug => Syslog::LOG_DEBUG }
+      SYMBOL_EQUIVALENTS = { fatal: Syslog::LOG_CRIT,
+                             error: Syslog::LOG_ERR,
+                             warn: Syslog::LOG_WARNING,
+                             info: Syslog::LOG_INFO,
+                             debug: Syslog::LOG_DEBUG }.freeze
 
       # Set the log level
       #   +level+ is the Symbol level to set as maximum. One of:
@@ -38,7 +37,6 @@ begin
         Syslog.log(SYMBOL_EQUIVALENTS[level], '%s', text)
       end
     end
-
   end
 rescue Object => e
   puts "Syslog could not be enabled: #{e.message}"

data/lib/god/system/portable_poller.rb

@@ -4,6 +4,7 @@ module God
       def initialize(pid)
         @pid = pid
       end
+
       # Memory usage in kilobytes (resident set size)
       def memory
         ps_int('rss')
@@ -28,15 +29,6 @@ module God
       def ps_float(keyword)
         `ps -o #{keyword}= -p #{@pid}`.to_f
       end
-
-      def ps_string(keyword)
-        `ps -o #{keyword}= -p #{@pid}`.strip
-      end
-
-      def time_string_to_seconds(text)
-        _, minutes, seconds, useconds = *text.match(/(\d+):(\d{2}).(\d{2})/)
-        (minutes.to_i * 60) + seconds.to_i
-      end
     end
   end
 end