firenxis-god 0.11.0

data/lib/god/errors.rb

@@ -0,0 +1,24 @@
+module God
+  
+  class AbstractMethodNotOverriddenError < StandardError
+  end
+  
+  class NoSuchWatchError < StandardError
+  end
+  
+  class NoSuchConditionError < StandardError
+  end
+  
+  class NoSuchBehaviorError < StandardError
+  end
+  
+  class NoSuchContactError < StandardError
+  end
+  
+  class InvalidCommandError < StandardError
+  end
+  
+  class EventRegistrationFailedError < StandardError
+  end
+  
+end

data/lib/god/event_handler.rb

@@ -0,0 +1,108 @@
+module God
+  class EventHandler
+    @@actions = {}
+    @@handler = nil
+    @@loaded = false
+    
+    def self.loaded?
+      @@loaded
+    end
+    
+    def self.event_system
+      @@handler::EVENT_SYSTEM
+    end
+    
+    def self.load
+      begin
+        case RUBY_PLATFORM
+        when /darwin/i, /bsd/i
+          require 'god/event_handlers/kqueue_handler'
+          @@handler = KQueueHandler
+        when /linux/i
+          require 'god/event_handlers/netlink_handler'
+          @@handler = NetlinkHandler
+        else
+          raise NotImplementedError, "Platform not supported for EventHandler"
+        end
+        @@loaded = true
+      rescue Exception
+        require 'god/event_handlers/dummy_handler'
+        @@handler = DummyHandler
+        @@loaded = false
+      end
+    end
+    
+    def self.register(pid, event, &block)
+      @@actions[pid] ||= {}
+      @@actions[pid][event] = block
+      @@handler.register_process(pid, @@actions[pid].keys)
+    end
+    
+    def self.deregister(pid, event)
+      if watching_pid? pid
+        running = ::Process.kill(0, pid.to_i) rescue false
+        @@actions[pid].delete(event)
+        @@handler.register_process(pid, @@actions[pid].keys) if running
+        @@actions.delete(pid) if @@actions[pid].empty?
+      end
+    end
+    
+    def self.call(pid, event, extra_data = {})
+      @@actions[pid][event].call(extra_data) if watching_pid?(pid) && @@actions[pid][event]
+    end
+    
+    def self.watching_pid?(pid)
+      @@actions[pid]
+    end
+    
+    def self.start
+      Thread.new do
+        loop do
+          begin
+            @@handler.handle_events
+          rescue Exception => e
+            message = format("Unhandled exception (%s): %s\n%s",
+                             e.class, e.message, e.backtrace.join("\n"))
+            applog(nil, :fatal, message)
+          end
+        end
+      end
+      
+      # do a real test to make sure events are working properly
+      @@loaded = self.operational?
+    end
+    
+    def self.operational?
+      com = [false]
+      
+      Thread.new do
+        begin
+          event_system = God::EventHandler.event_system
+          
+          pid = fork do
+            loop { sleep(1) }
+          end
+          
+          self.register(pid, :proc_exit) do
+            com[0] = true
+          end
+          
+          ::Process.kill('KILL', pid)
+          ::Process.waitpid(pid)
+          
+          sleep(0.1)
+          
+          self.deregister(pid, :proc_exit) rescue nil
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+        end
+      end.join
+      
+      sleep(0.1)
+      
+      com.first
+    end
+    
+  end
+end

data/lib/god/event_handlers/dummy_handler.rb

@@ -0,0 +1,13 @@
+module God
+  class DummyHandler
+    EVENT_SYSTEM = "none"
+    
+    def self.register_process
+      raise NotImplementedError
+    end
+    
+    def self.handle_events
+      raise NotImplementedError
+    end
+  end
+end

data/lib/god/event_handlers/kqueue_handler.rb

@@ -0,0 +1,17 @@
+require 'kqueue_handler_ext'
+
+module God
+  class KQueueHandler
+    EVENT_SYSTEM = "kqueue"
+    
+    def self.register_process(pid, events)
+      monitor_process(pid, events_mask(events))
+    end
+  
+    def self.events_mask(events)
+      events.inject(0) do |mask, event|
+        mask |= event_mask(event)
+      end
+    end
+  end
+end

data/lib/god/event_handlers/netlink_handler.rb

@@ -0,0 +1,13 @@
+require 'netlink_handler_ext'
+
+module God
+  class NetlinkHandler
+    EVENT_SYSTEM = "netlink"
+    
+    def self.register_process(pid, events)
+      # netlink doesn't need to do this
+      # it just reads from the eventhandler actions to see if the pid
+      # matches the list we're looking for -- Kev
+    end
+  end
+end

data/lib/god/logger.rb

@@ -0,0 +1,109 @@
+module God
+  
+  class Logger < SimpleLogger
+
+    attr_accessor :logs
+    
+    class << self
+      attr_accessor :syslog
+    end
+    
+    self.syslog = defined?(Syslog)
+    
+    # Instantiate a new Logger object
+    def initialize(io = $stdout)
+      super(io)
+      self.logs = {}
+      @mutex = Mutex.new
+      @capture = nil
+      @spool = Time.now - 10
+      @templogio = StringIO.new
+      @templog = SimpleLogger.new(@templogio)
+      @templog.level = Logger::INFO
+    end
+    
+    
+    def level=(lev)
+      SysLogger.level = SimpleLogger::CONSTANT_TO_SYMBOL[lev] if Logger.syslog
+      super(lev)
+    end
+    
+    # Log a message
+    #   +watch+ is the String name of the Watch (may be nil if not Watch is applicable)
+    #   +level+ is the log level [:debug|:info|:warn|:error|:fatal]
+    #   +text+ is the String message
+    #
+    # Returns nothing
+    def log(watch, level, text)
+      # initialize watch log if necessary
+      self.logs[watch.name] ||= Timeline.new(God::LOG_BUFFER_SIZE_DEFAULT) if watch
+
+      # push onto capture and timeline for the given watch
+      if @capture || (watch && (Time.now - @spool < 2))
+        @mutex.synchronize do
+          @templogio.truncate(0)
+          @templogio.rewind
+          @templog.send(level, text)
+
+          message = @templogio.string.dup
+
+          if @capture
+            @capture.puts(message)
+          else
+            self.logs[watch.name] << [Time.now, message]
+          end
+        end
+      end
+
+      # send to regular logger
+      self.send(level, text)
+
+      # send to syslog
+      SysLogger.log(level, text) if Logger.syslog
+    end
+    
+    # Get all log output for a given Watch since a certain Time.
+    #   +watch_name+ is the String name of the Watch
+    #   +since+ is the Time since which to fetch log lines
+    #
+    # Returns String
+    def watch_log_since(watch_name, since)
+      # initialize watch log if necessary
+      self.logs[watch_name] ||= Timeline.new(God::LOG_BUFFER_SIZE_DEFAULT)
+      
+      # get and join lines since given time
+      @mutex.synchronize do
+        @spool = Time.now
+        self.logs[watch_name].select do |x|
+          x.first > since
+        end.map do |x|
+          x[1]
+        end.join
+      end
+    end
+    
+    # private
+    
+    # Enable capturing of log
+    #
+    # Returns nothing
+    def start_capture
+      @mutex.synchronize do
+        @capture = StringIO.new
+      end
+    end
+    
+    # Disable capturing of log and return what was captured since
+    # capturing was enabled with Logger#start_capture
+    #
+    # Returns String
+    def finish_capture
+      @mutex.synchronize do
+        cap = @capture.string if @capture
+        @capture = nil
+        cap
+      end
+    end
+  end
+  
+end

data/lib/god/metric.rb

@@ -0,0 +1,59 @@
+module God
+  
+  class Metric
+    attr_accessor :watch, :destination, :conditions
+    
+    def initialize(watch, destination = nil)
+      self.watch = watch
+      self.destination = destination
+      self.conditions = []
+    end
+    
+    # Instantiate a Condition of type +kind+ and pass it into the optional
+    # block. Attributes of the condition must be set in the config file
+    def condition(kind)
+      # create the condition
+      begin
+        c = Condition.generate(kind, self.watch)
+      rescue NoSuchConditionError => e
+        abort e.message
+      end
+      
+      # send to block so config can set attributes
+      yield(c) if block_given?
+      
+      # call prepare on the condition
+      c.prepare
+      
+      # test generic and specific validity
+      unless Condition.valid?(c) && c.valid?
+        abort "Exiting on invalid condition"
+      end
+      
+      # inherit interval from watch if no poll condition specific interval was set
+      if c.kind_of?(PollCondition) && !c.interval
+        if self.watch.interval
+          c.interval = self.watch.interval
+        else
+          abort "No interval set for Condition '#{c.class.name}' in Watch '#{self.watch.name}', and no default Watch interval from which to inherit"
+        end
+      end
+      
+      # remember
+      self.conditions << c
+    end
+    
+    def enable
+      self.conditions.each do |c|
+        self.watch.attach(c)
+      end
+    end
+    
+    def disable
+      self.conditions.each do |c|
+        self.watch.detach(c)
+      end
+    end
+  end
+  
+end

data/lib/god/process.rb

@@ -0,0 +1,363 @@
+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
+    
+    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
+          uid_num = Etc.getpwnam(self.uid).uid if self.uid
+          gid_num = Etc.getgrnam(self.gid).gid if self.gid
+
+          ::Dir.chroot(self.chroot) if self.chroot
+          ::Process.groups = [gid_num] if self.gid
+          ::Process::Sys.setgid(gid_num) if self.gid
+          ::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
+          @stop_timeout.times do
+            begin
+              ::Process.kill(0, pid)
+            rescue Errno::ESRCH
+              # It died. Good.
+              applog(self, :info, "#{self.name} process stopped")
+              return
+            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
+            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
+        uid_num = Etc.getpwnam(self.uid).uid if self.uid
+        gid_num = Etc.getgrnam(self.gid).gid if self.gid
+
+        ::Dir.chroot(self.chroot) if self.chroot
+        ::Process.setsid
+        ::Process.groups = [gid_num] if self.gid
+        ::Process::Sys.setgid(gid_num) if self.gid
+        ::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
+          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