resurrected_god 0.14.0

data/lib/god/process.rb

@@ -0,0 +1,381 @@
+module God
+  class Process
+    WRITES_PID = [:start, :restart]
+
+    attr_accessor :name, :uid, :gid, :log, :log_cmd, :err_log, :err_log_cmd,
+                  :start, :stop, :restart, :unix_socket, :chroot, :env, :dir,
+                  :stop_timeout, :stop_signal, :umask
+
+    def initialize
+      self.log = '/dev/null'
+
+      @pid_file = nil
+      @tracking_pid = true
+      @user_log = false
+      @pid = nil
+      @unix_socket = nil
+      @log_cmd = nil
+      @stop_timeout = God::STOP_TIMEOUT_DEFAULT
+      @stop_signal = God::STOP_SIGNAL_DEFAULT
+    end
+
+    def alive?
+      if self.pid
+        System::Process.new(self.pid).exists?
+      else
+        false
+      end
+    end
+
+    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
+          end
+          if self.gid
+            group_method = self.gid.is_a?(Integer) ? :getgrgid : :getgrnam
+            gid_num = Etc.send(group_method, self.gid).gid
+          end
+
+          ::Dir.chroot(self.chroot) if self.chroot
+          ::Process.groups = [gid_num] if gid_num
+          ::Process.initgroups(self.uid, gid_num) if self.uid && gid_num
+          ::Process::Sys.setgid(gid_num) if gid_num
+          ::Process::Sys.setuid(uid_num) if self.uid
+        rescue ArgumentError, Errno::EPERM, Errno::ENOENT
+          exit(1)
+        end
+
+        File.writable?(file_in_chroot(file)) ? exit!(0) : exit!(1)
+      end
+
+      wpid, status = ::Process.waitpid2(pid)
+      status.exitstatus == 0 ? true : false
+    end
+
+    def valid?
+      # determine if we're tracking pid or not
+      self.pid_file
+
+      valid = true
+
+      # a start command must be specified
+      if self.start.nil?
+        valid = false
+        applog(self, :error, "No start command was specified")
+      end
+
+      # uid must exist if specified
+      if self.uid
+        begin
+          Etc.getpwnam(self.uid)
+        rescue ArgumentError
+          valid = false
+          applog(self, :error, "UID for '#{self.uid}' does not exist")
+        end
+      end
+
+      # gid must exist if specified
+      if self.gid
+        begin
+          Etc.getgrnam(self.gid)
+        rescue ArgumentError
+          valid = false
+          applog(self, :error, "GID for '#{self.gid}' does not exist")
+        end
+      end
+
+      # dir must exist and be a directory if specified
+      if self.dir
+        if !File.exist?(self.dir)
+          valid = false
+          applog(self, :error, "Specified directory '#{self.dir}' does not exist")
+        elsif !File.directory?(self.dir)
+          valid = false
+          applog(self, :error, "Specified directory '#{self.dir}' is not a directory")
+        end
+      end
+
+      # pid dir must exist if specified
+      if !@tracking_pid && !File.exist?(File.dirname(self.pid_file))
+        valid = false
+        applog(self, :error, "PID file directory '#{File.dirname(self.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))
+        valid = false
+        applog(self, :error, "PID file directory '#{File.dirname(self.pid_file)}' is not writable by #{self.uid || Etc.getlogin}")
+      end
+
+      # log dir must exist
+      if !File.exist?(File.dirname(self.log))
+        valid = false
+        applog(self, :error, "Log directory '#{File.dirname(self.log)}' does not exist")
+      end
+
+      # log file or dir must be writable
+      if File.exist?(self.log)
+        unless file_writable?(self.log)
+          valid = false
+          applog(self, :error, "Log file '#{self.log}' exists but is not writable by #{self.uid || Etc.getlogin}")
+        end
+      else
+        unless file_writable?(File.dirname(self.log))
+          valid = false
+          applog(self, :error, "Log directory '#{File.dirname(self.log)}' is not writable by #{self.uid || Etc.getlogin}")
+        end
+      end
+
+      # chroot directory must exist and have /dev/null in it
+      if self.chroot
+        if !File.directory?(self.chroot)
+          valid = false
+          applog(self, :error, "CHROOT directory '#{self.chroot}' does not exist")
+        end
+
+        if !File.exist?(File.join(self.chroot, '/dev/null'))
+          valid = false
+          applog(self, :error, "CHROOT directory '#{self.chroot}' does not contain '/dev/null'")
+        end
+      end
+
+      valid
+    end
+
+    # DON'T USE THIS INTERNALLY. Use the instance variable. -- Kev
+    # 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
+
+      @pid_file = value
+    end
+
+    def pid_file
+      @pid_file ||= default_pid_file
+    end
+
+    # Fetch the PID from pid_file. If the pid_file does not
+    # exist, then use the PID from the last time it was read.
+    # If it has never been read, then return nil.
+    #
+    # Returns Integer(pid) or nil
+    def pid
+      contents = File.read(self.pid_file).strip rescue ''
+      real_pid = contents =~ /^\d+$/ ? contents.to_i : nil
+
+      if real_pid
+        @pid = real_pid
+        real_pid
+      else
+        @pid
+      end
+    end
+
+    # Send the given signal to this process.
+    #
+    # 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
+    end
+
+    def start!
+      call_action(:start)
+    end
+
+    def stop!
+      call_action(:stop)
+    end
+
+    def restart!
+      call_action(:restart)
+    end
+
+    def default_pid_file
+      File.join(God.pid_file_directory, "#{self.name}.pid")
+    end
+
+    def call_action(action)
+      command = send(action)
+
+      if action == :stop && command.nil?
+        pid = self.pid
+        name = self.name
+        command = lambda do
+          applog(self, :info, "#{self.name} stop: default lambda killer")
+
+          ::Process.kill(@stop_signal, pid) rescue nil
+          applog(self, :info, "#{self.name} sent SIG#{@stop_signal}")
+
+          # Poll to see if it's dead
+          pid_not_found = false
+          @stop_timeout.times do
+            if pid
+              begin
+                ::Process.kill(0, pid)
+              rescue Errno::ESRCH
+                # It died. Good.
+                applog(self, :info, "#{self.name} process stopped")
+                return
+              end
+            else
+              applog(self, :warn, "#{self.name} pid not found in #{self.pid_file}") unless pid_not_found
+              pid_not_found = true
+            end
+
+            sleep 1
+          end
+
+          ::Process.kill('KILL', pid) rescue nil
+          applog(self, :warn, "#{self.name} still alive after #{@stop_timeout}s; sent SIGKILL")
+        end
+      end
+
+      if command.kind_of?(String)
+        pid = nil
+
+        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)
+              r.close
+              pid = self.spawn(command)
+              puts pid.to_s # send pid back to forker
+              exit!(0)
+            end
+
+            ::Process.waitpid(opid, 0)
+            w.close
+            pid = r.gets.chomp
+          ensure
+            # make sure the file descriptors get closed no matter what
+            r.close rescue nil
+            w.close rescue nil
+          end
+        else
+          # single fork self-daemonizing processes
+          # we want to wait for them to finish
+          pid = self.spawn(command)
+          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
+
+          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
+
+          @tracking_pid = true
+          @pid_file = default_pid_file
+        end
+      elsif command.kind_of?(Proc)
+        # lambda command
+        command.call
+      else
+        raise NotImplementedError
+      end
+    end
+
+    # Fork/exec the given command, returns immediately
+    #   +command+ is the String containing the shell command
+    #
+    # 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
+
+        ::Dir.chroot(self.chroot) if self.chroot
+        ::Process.setsid
+        ::Process.groups = [gid_num] if gid_num
+        ::Process.initgroups(self.uid, gid_num) if self.uid && gid_num
+        ::Process::Sys.setgid(gid_num) if gid_num
+        ::Process::Sys.setuid(uid_num) if self.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")
+        else
+          STDOUT.reopen file_in_chroot(self.log), "a"
+        end
+        if err_log_cmd
+          STDERR.reopen IO.popen(err_log_cmd, "a")
+        elsif err_log && (log_cmd || err_log != log)
+          STDERR.reopen file_in_chroot(err_log), "a"
+        else
+          STDERR.reopen STDOUT
+        end
+
+        # close any other file descriptors
+        3.upto(256){|fd| IO::new(fd).close rescue nil}
+
+        if self.env && self.env.is_a?(Hash)
+          self.env.each do |(key, value)|
+            ENV[key] = value.to_s
+          end
+        end
+
+        exec command unless command.empty?
+      end
+    end
+
+    # Ensure that a stop command actually stops the process. Force kill
+    # if necessary.
+    #
+    # Returns nothing
+    def ensure_stop
+      applog(self, :warn, "#{self.name} ensuring stop...")
+
+      unless self.pid
+        applog(self, :warn, "#{self.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)
+        rescue Errno::ESRCH
+          # It died. Good.
+          return
+        end
+
+        sleep 1
+      end
+
+      # last resort
+      ::Process.kill('KILL', self.pid) rescue nil
+      applog(self, :warn, "#{self.name} still alive after #{@stop_timeout}s; sent SIGKILL")
+    end
+
+    private
+    def file_in_chroot(file)
+      return file unless self.chroot
+
+      file.gsub(/^#{Regexp.escape(File.expand_path(self.chroot))}/, '')
+    end
+  end
+end

data/lib/god/registry.rb

@@ -0,0 +1,32 @@
+module God
+  def self.registry
+    @registry ||= Registry.new
+  end
+
+  class Registry
+    def initialize
+      @storage = {}
+    end
+
+    def add(item)
+      # raise TypeError unless item.is_a? God::Process
+      @storage[item.name] = item
+    end
+
+    def remove(item)
+      @storage.delete(item.name)
+    end
+
+    def size
+      @storage.size
+    end
+
+    def [](name)
+      @storage[name]
+    end
+
+    def reset
+      @storage.clear
+    end
+  end
+end

data/lib/god/simple_logger.rb

@@ -0,0 +1,59 @@
+module God
+
+  class SimpleLogger
+    DEBUG = 2
+    INFO = 4
+    WARN = 8
+    ERROR = 16
+    FATAL = 32
+
+    SEV_LABEL = {DEBUG => 'DEBUG',
+                 INFO => 'INFO',
+                 WARN => 'WARN',
+                 ERROR => 'ERROR',
+                 FATAL => 'FATAL'}
+
+    CONSTANT_TO_SYMBOL = { DEBUG => :debug,
+                           INFO => :info,
+                           WARN => :warn,
+                           ERROR => :error,
+                           FATAL => :fatal }
+
+    attr_accessor :datetime_format, :level
+
+    def initialize(io)
+      @io = io
+      @level = INFO
+      @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)
+      label = SEV_LABEL[level]
+      @io.print("#{label[0..0]} [#{time}] #{label.rjust(5)}: #{msg}\n")
+    end
+
+    def fatal(msg)
+      self.output(FATAL, msg)
+    end
+
+    def error(msg)
+      self.output(ERROR, msg)
+    end
+
+    def warn(msg)
+      self.output(WARN, msg)
+    end
+
+    def info(msg)
+      self.output(INFO, msg)
+    end
+
+    def debug(msg)
+      self.output(DEBUG, msg)
+    end
+  end
+
+end

data/lib/god/socket.rb

@@ -0,0 +1,113 @@
+require 'drb'
+
+module God
+
+  # The God::Server oversees the DRb server which dishes out info on this God daemon.
+  class Socket
+    attr_reader :port
+
+    # The location of the socket for a given port
+    #   +port+ is the port number
+    #
+    # Returns String (file location)
+    def self.socket_file(port)
+      "/tmp/god.#{port}.sock"
+    end
+
+    # The address of the socket for a given port
+    #   +port+ is the port number
+    #
+    # Returns String (drb address)
+    def self.socket(port)
+      "drbunix://#{self.socket_file(port)}"
+    end
+
+    # The location of the socket for this Server
+    #
+    # Returns String (file location)
+    def socket_file
+      self.class.socket_file(@port)
+    end
+
+    # The address of the socket for this Server
+    #
+    # Returns String (drb address)
+    def socket
+      self.class.socket(@port)
+    end
+
+    # Create a new Server and star the DRb server
+    #   +port+ is the port on which to start the DRb service (default nil)
+    def initialize(port = nil, user = nil, group = nil, perm = nil)
+      @port  = port
+      @user  = user
+      @group = group
+      @perm  = perm
+      start
+    end
+
+    # Returns true
+    def ping
+      true
+    end
+
+    # Forward API calls to God
+    #
+    # Returns whatever the forwarded call returns
+    def method_missing(*args, &block)
+      God.send(*args, &block)
+    end
+
+    # Stop the DRb server and delete the socket file
+    #
+    # Returns nothing
+    def stop
+      DRb.stop_service
+      FileUtils.rm_f(self.socket_file)
+    end
+
+    private
+
+    # Start the DRb server. Abort if there is already a running god instance
+    # on the socket.
+    #
+    # Returns nothing
+    def start
+      begin
+        @drb ||= DRb.start_service(self.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)
+
+        begin
+          Timeout.timeout(5) do
+            server.ping
+          end
+          abort "Socket #{self.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, "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
+
+        File.chmod(Integer(@perm), socket_file) if @perm
+        File.chown(uid, gid, socket_file) if uid or gid
+      end
+    end
+  end
+
+end

data/lib/god/sugar.rb

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

data/lib/god/sys_logger.rb

@@ -0,0 +1,45 @@
+begin
+  require 'syslog'
+
+  # Ensure that Syslog is open
+  begin
+    Syslog.open('god')
+  rescue RuntimeError
+    Syslog.reopen('god')
+  end
+
+  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 }
+
+      # Set the log level
+      #   +level+ is the Symbol level to set as maximum. One of:
+      #           [:fatal | :error | :warn | :info | :debug ]
+      #
+      # Returns Nothing
+      def self.level=(level)
+        Syslog.mask = Syslog::LOG_UPTO(SYMBOL_EQUIVALENTS[level])
+      end
+
+      # Log a message to syslog.
+      #   +level+ is the Symbol level of the message. One of:
+      #           [:fatal | :error | :warn | :info | :debug ]
+      #   +text+ is the String text of the message
+      #
+      # Returns Nothing
+      def self.log(level, text)
+        Syslog.log(SYMBOL_EQUIVALENTS[level], '%s', text)
+      end
+    end
+
+  end
+rescue Object => e
+  puts "Syslog could not be enabled: #{e.message}"
+end