mcproc 2016.2.20

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,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