resurrected_god 0.14.0

data/lib/god/cli/command.rb

@@ -0,0 +1,268 @@
+module God
+  module CLI
+
+    class Command
+      def initialize(command, options, args)
+        @command = command
+        @options = options
+        @args = args
+
+        dispatch
+      end
+
+      def setup
+        # connect to drb unix socket
+        @server = DRbObject.new(nil, God::Socket.socket(@options[:port]))
+
+        # ping server to ensure that it is responsive
+        begin
+          @server.ping
+        rescue DRb::DRbConnError
+          puts "The server is not available (or you do not have permissions to access it)"
+          abort
+        end
+      end
+
+      def dispatch
+        if %w{load status signal log quit terminate}.include?(@command)
+          setup
+          send("#{@command}_command")
+        elsif %w{start stop restart monitor unmonitor remove}.include?(@command)
+          setup
+          lifecycle_command
+        elsif @command == 'check'
+          check_command
+        else
+          puts "Command '#{@command}' is not valid. Run 'god --help' for usage"
+          abort
+        end
+      end
+
+      def load_command
+        file = @args[1]
+        action = @args[2] || 'leave'
+
+        unless ['stop', 'remove', 'leave', ''].include?(action)
+          puts "Command '#{@command}' action must be either 'stop', 'remove' or 'leave'"
+          exit(1)
+        end
+
+        puts "Sending '#{@command}' command with action '#{action}'"
+        puts
+
+        unless File.exist?(file)
+          abort "File not found: #{file}"
+        end
+
+        affected, errors, removed = *@server.running_load(File.read(file), File.expand_path(file), action)
+
+        # output response
+        unless affected.empty?
+          puts 'The following tasks were affected:'
+          affected.each do |w|
+            puts '  ' + w
+          end
+        end
+
+        unless removed.empty?
+          puts 'The following tasks were removed:'
+          removed.each do |w|
+            puts '  ' + w
+          end
+        end
+
+        unless errors.empty?
+          puts errors
+          exit(1)
+        end
+      end
+
+      def status_command
+        exitcode = 0
+        statuses = @server.status
+        groups = {}
+        statuses.each do |name, status|
+          g = status[:group] || ''
+          groups[g] ||= {}
+          groups[g][name] = status
+        end
+
+        if item = @args[1]
+          if single = statuses[item]
+            # specified task (0 -> up, 1 -> unmonitored, 2 -> other)
+            state = single[:state]
+            puts "#{item}: #{state}"
+            exitcode = state == :up ? 0 : (state == :unmonitored ? 1 : 2)
+          elsif groups[item]
+            # specified group (0 -> up, N -> other)
+            puts "#{item}:"
+            groups[item].keys.sort.each do |name|
+              state = groups[item][name][:state]
+              print "  "
+              puts "#{name}: #{state}"
+              exitcode += 1 unless state == :up
+            end
+          else
+            puts "Task or Group '#{item}' not found."
+            exit(1)
+          end
+        else
+          # show all groups and watches
+          groups.keys.sort.each do |group|
+            puts "#{group}:" unless group.empty?
+            groups[group].keys.sort.each do |name|
+              state = groups[group][name][:state]
+              print "  " unless group.empty?
+              puts "#{name}: #{state}"
+            end
+          end
+        end
+
+        exit(exitcode)
+      end
+
+      def signal_command
+        # get the name of the watch/group
+        name = @args[1]
+        signal = @args[2]
+
+        puts "Sending signal '#{signal}' to '#{name}'"
+
+        t = Thread.new { loop { sleep(1); STDOUT.print('.'); STDOUT.flush; sleep(1) } }
+
+        watches = @server.signal(name, signal)
+
+        # output response
+        t.kill; STDOUT.puts
+        unless watches.empty?
+          puts 'The following watches were affected:'
+          watches.each do |w|
+            puts '  ' + w
+          end
+        else
+          puts 'No matching task or group'
+        end
+      end
+
+      def log_command
+        begin
+          Signal.trap('INT') { exit }
+          name = @args[1]
+
+          unless name
+            puts "You must specify a Task or Group name"
+            exit!
+          end
+
+          puts "Please wait..."
+          t = Time.at(0)
+          loop do
+            print @server.running_log(name, t)
+            t = Time.now
+            sleep 0.25
+          end
+        rescue God::NoSuchWatchError
+          puts "No such watch"
+        rescue DRb::DRbConnError
+          puts "The server went away"
+        end
+      end
+
+      def quit_command
+        begin
+          @server.terminate
+          abort 'Could not stop god'
+        rescue DRb::DRbConnError
+          puts 'Stopped god'
+        end
+      end
+
+      def terminate_command
+        t = Thread.new { loop { STDOUT.print('.'); STDOUT.flush; sleep(1) } }
+        if @server.stop_all
+          t.kill; STDOUT.puts
+          puts 'Stopped all watches'
+        else
+          t.kill; STDOUT.puts
+          puts "Could not stop all watches within #{@server.terminate_timeout} seconds"
+        end
+
+        begin
+          @server.terminate
+          abort 'Could not stop god'
+        rescue DRb::DRbConnError
+          puts 'Stopped god'
+        end
+      end
+
+      def check_command
+        Thread.new do
+          begin
+            event_system = God::EventHandler.event_system
+            puts "using event system: #{event_system}"
+
+            if God::EventHandler.loaded?
+              puts "starting event handler"
+              God::EventHandler.start
+            else
+              puts "[fail] event system did not load"
+              exit(1)
+            end
+
+            puts 'forking off new process'
+
+            pid = fork do
+              loop { sleep(1) }
+            end
+
+            puts "forked process with pid = #{pid}"
+
+            God::EventHandler.register(pid, :proc_exit) do
+              puts "[ok] process exit event received"
+              exit!(0)
+            end
+
+            sleep(1)
+
+            puts "killing process"
+
+            ::Process.kill('KILL', pid)
+            ::Process.waitpid(pid)
+          rescue => e
+            puts e.message
+            puts e.backtrace.join("\n")
+          end
+        end
+
+        sleep(2)
+
+        puts "[fail] never received process exit event"
+        exit(1)
+      end
+
+      def lifecycle_command
+        # get the name of the watch/group
+        name = @args[1]
+
+        puts "Sending '#{@command}' command"
+
+        t = Thread.new { loop { sleep(1); STDOUT.print('.'); STDOUT.flush; sleep(1) } }
+
+        # send @command
+        watches = @server.control(name, @command)
+
+        # output response
+        t.kill; STDOUT.puts
+        unless watches.empty?
+          puts 'The following watches were affected:'
+          watches.each do |w|
+            puts '  ' + w
+          end
+        else
+          puts 'No matching task or group'
+        end
+      end
+    end # Command
+
+  end
+end

data/lib/god/cli/run.rb

@@ -0,0 +1,170 @@
+module God
+  module CLI
+
+    class Run
+      def initialize(options)
+        @options = options
+
+        dispatch
+      end
+
+      def dispatch
+        # have at_exit start god
+        $run = true
+
+        if @options[:syslog]
+          require 'god/sys_logger'
+        end
+
+        # run
+        if @options[:daemonize]
+          run_daemonized
+        else
+          run_in_front
+        end
+      end
+
+      def attach
+        process = System::Process.new(@options[:attach])
+        Thread.new do
+          loop do
+            unless process.exists?
+              applog(nil, :info, "Going down because attached process #{@options[:attach]} exited")
+              exit!
+            end
+            sleep 5
+          end
+        end
+      end
+
+      def default_run
+        # make sure we have STDIN/STDOUT redirected immediately
+        setup_logging
+
+        # start attached pid watcher if necessary
+        if @options[:attach]
+          self.attach
+        end
+
+        if @options[:port]
+          God.port = @options[:port]
+        end
+
+        if @options[:events]
+          God::EventHandler.load
+        end
+
+        # set log level, defaults to WARN
+        if @options[:log_level]
+          God.log_level = @options[:log_level]
+        else
+          God.log_level = @options[:daemonize] ? :warn : :info
+        end
+
+        if @options[:config]
+          if !@options[:config].include?('*') && !File.exist?(@options[:config])
+            abort "File not found: #{@options[:config]}"
+          end
+
+          # start the event handler
+          God::EventHandler.start if God::EventHandler.loaded?
+
+          load_config @options[:config]
+        end
+        setup_logging
+      end
+
+      def run_in_front
+        require 'god'
+
+        default_run
+      end
+
+      def run_daemonized
+        # trap and ignore SIGHUP
+        Signal.trap('HUP') {}
+        # trap and log-reopen SIGUSR1
+        Signal.trap('USR1') { setup_logging }
+
+        pid = fork do
+          begin
+            require 'god'
+
+            # set pid if requested
+            if @options[:pid] # and as deamon
+              God.pid = @options[:pid]
+            end
+
+            default_run
+
+            unless God::EventHandler.loaded?
+              puts
+              puts "***********************************************************************"
+              puts "*"
+              puts "* Event conditions are not available for your installation of god."
+              puts "* You may still use and write custom conditions using the poll system"
+              puts "*"
+              puts "***********************************************************************"
+              puts
+            end
+
+          rescue => e
+            puts e.message
+            puts e.backtrace.join("\n")
+            abort "There was a fatal system error while starting god (see above)"
+          end
+        end
+
+        if @options[:pid]
+          File.open(@options[:pid], 'w') { |f| f.write pid }
+        end
+
+        ::Process.detach pid
+
+        exit
+      end
+
+      def setup_logging
+        log_file = God.log_file
+        log_file = File.expand_path(@options[:log]) if @options[:log]
+        log_file = "/dev/null" if !log_file && @options[:daemonize]
+        if log_file
+          puts "Sending output to log file: #{log_file}" unless @options[:daemonize]
+
+          # reset file descriptors
+          STDIN.reopen "/dev/null"
+          STDOUT.reopen(log_file, "a")
+          STDERR.reopen STDOUT
+          STDOUT.sync = true
+        end
+      end
+
+      def load_config(config)
+        files = File.directory?(config) ? Dir['**/*.god'] : Dir[config]
+        abort "No files could be found" if files.empty?
+        files.each do |god_file|
+          unless load_god_file(god_file)
+            abort "File '#{god_file}' could not be loaded"
+          end
+        end
+      end
+
+      def load_god_file(god_file)
+        applog(nil, :info, "Loading #{god_file}")
+        load File.expand_path(god_file)
+        true
+      rescue Exception => e
+        if e.instance_of?(SystemExit)
+          raise
+        else
+          puts "There was an error in #{god_file}"
+          puts "\t" + e.message
+          puts "\t" + e.backtrace.join("\n\t")
+          false
+        end
+      end
+
+    end # Run
+
+  end
+end

data/lib/god/cli/version.rb

@@ -0,0 +1,23 @@
+module God
+  module CLI
+
+    class Version
+      def self.version
+        require 'god'
+
+        # print version
+        puts "Version #{God.version}"
+        exit
+      end
+
+      def self.version_extended
+        puts "Version: #{God.version}"
+        puts "Polls: enabled"
+        puts "Events: " + God::EventHandler.event_system
+
+        exit
+      end
+    end
+
+  end
+end

data/lib/god/compat19.rb

@@ -0,0 +1,33 @@
+require 'monitor'
+
+# Taken from http://redmine.ruby-lang.org/repositories/entry/ruby-19/lib/monitor.rb
+
+module MonitorMixin
+  class ConditionVariable
+    def wait(timeout = nil)
+      @monitor.__send__(:mon_check_owner)
+      count = @monitor.__send__(:mon_exit_for_cond)
+      begin
+        @cond.wait(@monitor.instance_variable_get("@mon_mutex"), timeout)
+        return true
+      ensure
+        @monitor.__send__(:mon_enter_for_cond, count)
+      end
+    end
+  end
+end
+
+# Taken from http://redmine.ruby-lang.org/repositories/entry/ruby-19/lib/thread.rb
+
+class ConditionVariable
+  def wait(mutex, timeout=nil)
+    begin
+      # TODO: mutex should not be used
+      @waiters_mutex.synchronize do
+        @waiters.push(Thread.current)
+      end
+      mutex.sleep timeout
+    end
+    self
+  end
+end

data/lib/god/condition.rb

@@ -0,0 +1,96 @@
+module God
+
+  class Condition < Behavior
+    attr_accessor :transition, :notify, :info, :phase
+
+    # Generate a Condition of the given kind. The proper class if found by camel casing the
+    # kind (which is given as an underscored symbol).
+    #   +kind+ is the underscored symbol representing the class (e.g. :foo_bar for God::Conditions::FooBar)
+    def self.generate(kind, watch)
+      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      c = God::Conditions.const_get(sym).new
+
+      unless c.kind_of?(PollCondition) || c.kind_of?(EventCondition) || c.kind_of?(TriggerCondition)
+        abort "Condition '#{c.class.name}' must subclass God::PollCondition, God::EventCondition, or God::TriggerCondition"
+      end
+
+      if !EventHandler.loaded? && c.kind_of?(EventCondition)
+        abort "Condition '#{c.class.name}' requires an event system but none has been loaded"
+      end
+
+      c.watch = watch
+      c
+    rescue NameError
+      raise NoSuchConditionError.new("No Condition found with the class name God::Conditions::#{sym}")
+    end
+
+    def self.valid?(condition)
+      valid = true
+      if condition.notify
+        begin
+          Contact.normalize(condition.notify)
+        rescue ArgumentError => e
+          valid &= Configurable.complain("Attribute 'notify' " + e.message, condition)
+        end
+      end
+      valid
+    end
+
+    # Construct the friendly name of this Condition, looks like:
+    #
+    # Condition FooBar on Watch 'baz'
+    def friendly_name
+      "Condition #{self.class.name.split('::').last} on Watch '#{self.watch.name}'"
+    end
+  end
+
+  class PollCondition < Condition
+    # all poll conditions can specify a poll interval
+    attr_accessor :interval
+
+    # Override this method in your Conditions (optional)
+    def before
+    end
+
+    # Override this method in your Conditions (mandatory)
+    #
+    # Return true if the test passes (everything is ok)
+    # Return false otherwise
+    def test
+      raise AbstractMethodNotOverriddenError.new("PollCondition#test must be overridden in subclasses")
+    end
+
+    # Override this method in your Conditions (optional)
+    def after
+    end
+  end
+
+  class EventCondition < Condition
+    def register
+      raise AbstractMethodNotOverriddenError.new("EventCondition#register must be overridden in subclasses")
+    end
+
+    def deregister
+      raise AbstractMethodNotOverriddenError.new("EventCondition#deregister must be overridden in subclasses")
+    end
+  end
+
+  class TriggerCondition < Condition
+    def process(event, payload)
+      raise AbstractMethodNotOverriddenError.new("TriggerCondition#process must be overridden in subclasses")
+    end
+
+    def trigger
+      self.watch.trigger(self)
+    end
+
+    def register
+      Trigger.register(self)
+    end
+
+    def deregister
+      Trigger.deregister(self)
+    end
+  end
+
+end

data/lib/god/conditions/always.rb

@@ -0,0 +1,36 @@
+module God
+  module Conditions
+    # Always trigger or never trigger.
+    #
+    # Examples
+    #
+    #   # Always trigger.
+    #   on.condition(:always) do |c|
+    #     c.what = true
+    #   end
+    #
+    #   # Never trigger.
+    #   on.condition(:always) do |c|
+    #     c.what = false
+    #   end
+    class Always < PollCondition
+      # The Boolean determining whether this condition will always trigger
+      # (true) or never trigger (false).
+      attr_accessor :what
+
+      def initialize
+        self.info = "always"
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'what' must be specified", self) if self.what.nil?
+        valid
+      end
+
+      def test
+        @what
+      end
+    end
+  end
+end

data/lib/god/conditions/complex.rb

@@ -0,0 +1,86 @@
+module God
+  module Conditions
+
+    class Complex < PollCondition
+      AND = 0x1
+      OR  = 0x2
+      NOT = 0x4
+
+      def initialize()
+        super
+
+        @oper_stack = []
+        @op_stack = []
+
+        @this = nil
+      end
+
+      def valid?
+        @oper_stack.inject(true) { |acc, oper| acc & oper.valid? }
+      end
+
+      def prepare
+        @oper_stack.each { |oper| oper.prepare }
+      end
+
+      def new_oper(kind, op)
+        oper = Condition.generate(kind, self.watch)
+        @oper_stack.push(oper)
+        @op_stack.push(op)
+        oper
+      end
+
+      def this(kind)
+        @this = Condition.generate(kind, self.watch)
+        yield @this if block_given?
+      end
+
+      def and(kind)
+        oper = new_oper(kind, 0x1)
+        yield oper if block_given?
+      end
+
+      def and_not(kind)
+        oper = new_oper(kind, 0x5)
+        yield oper if block_given?
+      end
+
+      def or(kind)
+        oper = new_oper(kind, 0x2)
+        yield oper if block_given?
+      end
+
+      def or_not(kind)
+        oper = new_oper(kind, 0x6)
+        yield oper if block_given?
+      end
+
+      def test
+        if @this.nil?
+          # Although this() makes sense semantically and therefore
+          # encourages easy-to-read conditions, being able to omit it
+          # allows for more DRY code in some cases, so we deal with a
+          # nil @this here by initially setting res to true or false,
+          # depending on whether the first operator used is AND or OR
+          # respectively.
+          if 0 < @op_stack[0] & AND
+            res = true
+          else
+            res = false
+          end
+        else
+          res = @this.test
+        end
+
+        @op_stack.each do |op|
+          cond = @oper_stack.shift
+          eval "res " + ((0 < op & AND) ? "&&" : "||") + "= " + ((0 < op & NOT) ? "!" : "") + "cond.test"
+          @oper_stack.push cond
+        end
+
+        res
+      end
+    end
+
+  end
+end