mojombo-god 0.7.7

data/lib/god/behavior.rb

@@ -0,0 +1,52 @@
+module God
+  
+  class Behavior
+    include Configurable
+    
+    attr_accessor :watch
+    
+    # Generate a Behavior of the given kind. The proper class is 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::Behaviors::FooBar)
+    def self.generate(kind, watch)
+      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      b = God::Behaviors.const_get(sym).new
+      b.watch = watch
+      b
+    rescue NameError
+      raise NoSuchBehaviorError.new("No Behavior found with the class name God::Behaviors::#{sym}")
+    end
+    
+    def valid?
+      true
+    end
+        
+    #######
+    
+    def before_start
+    end
+    
+    def after_start
+    end
+    
+    def before_restart
+    end
+    
+    def after_restart
+    end
+    
+    def before_stop
+    end
+    
+    def after_stop
+    end
+    
+    # Construct the friendly name of this Behavior, looks like:
+    #
+    # Behavior FooBar on Watch 'baz'
+    def friendly_name
+      "Behavior " + super + " on Watch '#{self.watch.name}'"
+    end
+  end
+  
+end

data/lib/god/behaviors/clean_pid_file.rb

@@ -0,0 +1,21 @@
+module God
+  module Behaviors
+    
+    class CleanPidFile < Behavior
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid
+      end
+  
+      def before_start
+        File.delete(self.watch.pid_file)
+        
+        "deleted pid file"
+      rescue
+        "no pid file to delete"
+      end
+    end
+  
+  end
+end

data/lib/god/behaviors/clean_unix_socket.rb

@@ -0,0 +1,21 @@
+module God
+  module Behaviors
+    
+    class CleanUnixSocket < Behavior
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'unix_socket' must be specified", self) if self.watch.unix_socket.nil?
+        valid
+      end 
+      
+      def before_start 
+        File.delete(self.watch.unix_socket)
+        
+        "deleted unix socket" 
+      rescue 
+        "no unix socket to delete" 
+      end
+    end
+  
+  end
+end

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,206 @@
+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 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 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,177 @@
+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
+        # 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
+      end
+      
+      def run_in_front
+        require 'god'
+        
+        if @options[:bleakhouse]
+          BleakHouseDiagnostic.install
+        end
+        
+        default_run
+        
+        log_file = God.log_file
+        log_file = File.expand_path(@options[:log]) if @options[:log]        
+        if log_file
+          puts "Sending output to log file: #{log_file}"
+          
+          # reset file descriptors
+          STDIN.reopen "/dev/null"
+          STDOUT.reopen(log_file, "a")
+          STDERR.reopen STDOUT
+          STDOUT.sync = true
+        end
+      end
+      
+      def run_daemonized
+        # trap and ignore SIGHUP
+        Signal.trap('HUP') {}
+        
+        pid = fork do
+          begin
+            require 'god'
+            
+            log_file = @options[:log] || God.log_file || "/dev/null"
+            
+            # reset file descriptors
+            STDIN.reopen "/dev/null"
+            STDOUT.reopen(log_file, "a")
+            STDERR.reopen STDOUT
+            STDOUT.sync = true
+            
+            # 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 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