strobemonkey-god 0.7.13

data/lib/god/behaviors/notify_when_flapping.rb

@@ -0,0 +1,51 @@
+module God
+  module Behaviors
+    
+    class NotifyWhenFlapping < Behavior
+      attr_accessor :failures # number of failures 
+      attr_accessor :seconds  # number of seconds
+      attr_accessor :notifier # class to notify with
+      
+      def initialize
+        super
+        @startup_times = []
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'failures' must be specified", self) unless self.failures
+        valid &= complain("Attribute 'seconds' must be specified", self) unless self.seconds
+        valid &= complain("Attribute 'notifier' must be specified", self) unless self.notifier
+                
+        # Must take one arg or variable args
+        unless self.notifier.respond_to?(:notify) and [1,-1].include?(self.notifier.method(:notify).arity)
+          valid &= complain("The 'notifier' must have a method 'notify' which takes 1 or variable args", self)
+        end
+        
+        valid
+      end
+  
+      def before_start
+        now = Time.now.to_i
+        @startup_times << now
+        check_for_flapping(now)
+      end
+      
+      def before_restart
+        now = Time.now.to_i
+        @startup_times << now
+        check_for_flapping(now)
+      end
+      
+      private
+        
+        def check_for_flapping(now)
+          @startup_times.select! {|time| time >= now - self.seconds }
+          if @startup_times.length >= self.failures
+            self.notifier.notify("#{self.watch.name} has called start/restart #{@startup_times.length} times in #{self.seconds} seconds")
+          end
+        end
+    end
+  
+  end
+end

data/lib/god/cli/command.rb

@@ -0,0 +1,229 @@
+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
+        DRb.start_service("druby://127.0.0.1:0")
+        @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]
+          
+        puts "Sending '#{@command}' command"
+        puts
+        
+        unless File.exist?(file)
+          abort "File not found: #{file}"
+        end
+        
+        names, errors = *@server.running_load(File.read(file), File.expand_path(file))
+        
+        # output response
+        unless names.empty?
+          puts 'The following tasks were affected:'
+          names.each do |w|
+            puts '  ' + w
+          end
+        end
+        
+        unless errors.empty?
+          puts errors
+          exit(1)
+        end
+      end
+      
+      def status_command
+        watches = {}
+        @server.status.each do |name, status|
+          g = status[:group] || ''
+          unless watches.has_key?(g)
+            watches[g] = {}
+          end
+          watches[g][name] = status
+        end
+        watches.keys.sort.each do |group|
+          puts "#{group}:" unless group.empty?
+          watches[group].keys.sort.each do |name|
+            state = watches[group][name][:state]
+            print "  " unless group.empty?
+            puts "#{name}: #{state}"
+          end
+        end
+      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
+          
+          t = Time.at(0)
+          loop do
+            print @server.running_log(name, t)
+            t = Time.now
+            sleep 1
+          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 10 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)
+          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,176 @@
+module God
+  module CLI
+    
+    class Run
+      def initialize(options)
+        @options = options
+        
+        dispatch
+      end
+      
+      def dispatch
+        # have at_exit start god
+        $run = true
+        
+        # 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]
+          unless 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'
+        
+        if @options[:bleakhouse]
+          BleakHouseDiagnostic.install
+        end
+        
+        default_run
+      end
+      
+      def run_daemonized
+        # trap and ignore SIGHUP
+        Signal.trap('HUP') {}
+        
+        pid = fork do
+          begin
+            require 'god'
+            
+            # set pid if requested
+            if @options[:pid] # and as deamon
+              God.pid = @options[:pid] 
+            end
+            
+            unless @options[:syslog]
+              Logger.syslog = false
+            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)
+        if File.directory? config
+          files_loaded = false
+          Dir[File.expand_path('**/*.god', config)].each do |god_file|
+            files_loaded ||= load_god_file(File.expand_path(god_file))
+          end
+          unless files_loaded
+            abort "No files could be loaded"
+          end
+        else
+          unless load_god_file(File.expand_path(config))
+            abort "File could not be loaded"
+          end
+        end
+      end
+      
+      def load_god_file(god_file)
+        load File.expand_path(god_file)
+      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")
+          return 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/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,23 @@
+module God
+  module Conditions
+
+    class Always < PollCondition
+      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