prometheus-splash 0.1.0 → 0.1.1

data/lib/splash/cli.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+Dir[File.dirname(__FILE__) + '/cli/*.rb'].each {|file| require file  }
+
+class CLI < Thor
+  def self.exit_on_failure?
+    true
+  end
+
+  include CLISplash
+  desc "commands SUBCOMMAND ...ARGS", "Managing commands/batchs supervision"
+  subcommand "commands", Commands
+  desc "logs SUBCOMMAND ...ARGS", "Managing Files/Logs supervision"
+  subcommand "logs", Logs
+  desc "daemon SUBCOMMAND ...ARGS", "Logs monitor daemon contoller"
+  subcommand "daemon", CLIController
+  desc "config SUBCOMMAND ...ARGS", "config tools for Splash"
+  subcommand "config", Config
+  desc "documentation SUBCOMMAND ...ARGS", "Documentation for Splash"
+  subcommand "documentation", Documentation
+end

data/lib/splash/cli/commands.rb

@@ -0,0 +1,164 @@
+# coding: utf-8
+module CLISplash
+
+
+  class Commands < Thor
+    include Splash::Config
+    include Splash::Backends
+    include Splash::Exiter
+
+    desc "execute NAME", "run for command/sequence or ack result"
+    long_desc <<-LONGDESC
+    execute command or sequence or ack result
+    with --no-trace prevent storing execution trace in configured backend (see config file)
+    with --ack, notify errorcode=0 to Prometheus PushGateway
+    with --no-notify, bypass Prometheus notification
+    with --no-callback, never execute callback (:on_failure, :on_success)
+                        never follow sequences
+    LONGDESC
+    option :trace, :type => :boolean, :default => true
+    option :ack, :type => :boolean, negate: false
+    option :notify, :type => :boolean, :default => true
+    option :callback, :type => :boolean, :default => true
+    def execute(name)
+      if is_root? then
+        command =  Splash::CommandWrapper::new(name)
+        if options[:ack] then
+          splash_exit command.ack
+        end
+        acase = command.call_and_notify trace: options[:trace], notify: options[:notify], callback: options[:callback]
+        splash_exit acase
+      else
+        splash_exit case: :not_root, :more => "Command execution"
+      end
+    end
+
+
+    desc "treeview", "Show commands sequence tree"
+    def treeview(command, depht = 0)
+      puts "Command : #{command.to_s}" if depht == 0
+      cmd  = get_config.commands[command.to_sym]
+      if cmd[:on_failure] then
+        print " " * depht + " "
+        puts "* on failure => #{cmd[:on_failure]}"
+        treeview(cmd[:on_failure], depht+2)
+      end
+      if cmd[:on_success] then
+        print " " * depht + " "
+        puts "* on success => #{cmd[:on_success]}"
+        treeview(cmd[:on_success],depht+2)
+      end
+      splash_exit case: :quiet_exit
+    end
+
+
+    desc "list", "Show configured commands"
+    long_desc <<-LONGDESC
+    Show configured commands
+    with --detail, show command details
+    LONGDESC
+    option :detail, :type => :boolean
+    def list
+      puts "Splash configured commands :"
+      list = get_config.commands
+      puts 'No configured commands found' if list.keys.empty?
+      list.keys.each do |command|
+        puts " * #{command.to_s}"
+        if options[:detail] then
+          puts "   - command line : '#{list[command][:command]}'"
+          puts "   - command description : '#{list[command][:desc]}'"
+          puts "   - command failure callback : '#{list[command.to_sym][:on_failure]}'" if list[command.to_sym][:on_failure]
+          puts "   - command success callback : '#{list[command.to_sym][:on_success]}'" if list[command.to_sym][:on_success]
+        end
+      end
+      splash_exit case: :quiet_exit
+    end
+
+
+    desc "show COMMAND", "Show specific configured command COMMAND"
+    def show(command)
+      list = get_config.commands
+      if list.keys.include? command.to_sym then
+        puts "Splash command : #{command}"
+        puts "   - command line : '#{list[command.to_sym][:command]}'"
+        puts "   - command description : '#{list[command.to_sym][:desc]}'"
+        puts "   - command failure callback : '#{list[command.to_sym][:on_failure]}'" if list[command.to_sym][:on_failure]
+        puts "   - command success callback : '#{list[command.to_sym][:on_success]}'" if list[command.to_sym][:on_success]
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_found, :more => 'Command not configured'
+      end
+    end
+
+
+    desc "lastrun COMMAND", "Show last running result for specific configured command COMMAND"
+    long_desc <<-LONGDESC
+    Show last running result for specific configured command COMMAND
+    with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
+    LONGDESC
+    option :hostname, :type => :string
+    def lastrun(command)
+      backend = get_backend :execution_trace
+      redis = (backend.class == Splash::Backends::Redis)? true : false
+      if not redis and options[:hostname] then
+        splash_exit case: :specific_config_required, :more => "Redis backend is requiered for Remote execution report request"
+      end
+      list = get_config.commands
+      if list.keys.include? command.to_sym then
+        print "Splash command #{command} previous execution report:\n\n"
+        req  = { :key => command}
+        req[:hostname] = options[:hostname] if options[:hostname]
+        if backend.exist? req then
+          print backend.get req
+        else
+          puts "Command not already runned."
+        end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :command_not_configured
+      end
+    end
+
+    desc "getreportlist", "list all executions report results "
+    long_desc <<-LONGDESC
+    list all executions report results
+    with --pattern <SEARCH>, search type string, wilcard * (group) ? (char)\n
+    with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)\n
+    with --all, get all execution report for all servers (only with Redis backend configured)\n
+    --all and --hostname are exclusives
+    LONGDESC
+    option :pattern, :type => :string
+    option :hostname, :type => :string
+    option :all, :type => :boolean, :negate => false
+    def getreportlist
+      if options[:hostname] and options[:all] then
+        splash_exit case: :options_incompatibility, more: "--all, --hostname"
+      end
+      backend = get_backend :execution_trace
+      redis = (backend.class == Splash::Backends::Redis)? true : false
+      if not redis and (options[:hostname] or options[:all]) then
+        splash_exit case: :redis_back_required, more: "Remote execution report Request"
+      end
+      pattern = (options[:pattern])? options[:pattern] : '*'
+      if options[:all] then
+        res = backend.listall pattern
+      elsif options[:hostname]
+        res = backend.list pattern, options[:hostname]
+      else
+        res = backend.list pattern
+      end
+      print "List of Executions reports :\n\n"
+      puts "Not reports found" if res.empty?
+      res.each do |item|
+        if options[:all]
+          host,command = item.split('#')
+          puts " * Command : #{command} @ host : #{host}"
+        else
+          puts " * Command : #{item}"
+        end
+      end
+      splash_exit case: :quiet_exit
+    end
+
+  end
+end

data/lib/splash/cli/config.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+module CLISplash
+
+  class Config < Thor
+    include Splash::Config
+    include Splash::Helpers
+    include Splash::Exiter
+
+
+    desc "setup", "Setup installation fo Splash"
+    long_desc <<-LONGDESC
+    Setup installation fo Splash
+    with --preserve, preserve from reinstallation of the config
+    LONGDESC
+    option :preserve, :type => :boolean
+    def setup
+      acase = run_as_root :setupsplash
+      splash_exit acase
+    end
+
+    desc "sanitycheck", "Verify installation fo Splash"
+    def sanitycheck
+      acase = run_as_root :checkconfig
+      splash_exit acase
+    end
+
+    desc "version", "display current Splash version"
+    def version
+      config = get_config
+      puts "Splash version : #{config.version}, Author : #{config.author}"
+      puts config.copyright
+      splash_exit case: :quiet_exit
+    end
+
+  end
+
+end

data/lib/splash/cli/daemon.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+module CLISplash
+
+  class CLIController < Thor
+    include Splash::LogsMonitor::DaemonController
+    include Splash::Transports
+    include Splash::Exiter
+
+
+    option :foreground, :type => :boolean
+    desc "start", "Starting Logs Monitor Daemon"
+    def start
+      acase = run_as_root :startdaemon
+      splash_exit acase
+    end
+
+    desc "stop", "Stopping Logs Monitor Daemon"
+    def stop
+      acase = run_as_root :stopdaemon
+      splash_exit acase
+    end
+
+    desc "status", "Logs Monitor Daemon status"
+    def status
+      acase = run_as_root :statusdaemon
+      splash_exit acase
+    end
+
+    desc "ping HOSTNAME", "send a ping to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
+    def ping(hostname=Socket.gethostname)
+      puts "ctrl+c for interrupt"
+      queue = "splash.#{Socket.gethostname}.returncli"
+      order = {:verb => :ping, :payload => {:hostname => Socket.gethostname}, :return_to => queue}
+
+      lock = Mutex.new
+      condition = ConditionVariable.new
+      begin
+        get_default_subscriber(queue: queue).subscribe(timeout: 10) do |delivery_info, properties, payload|
+          puts YAML::load(payload)
+          lock.synchronize { condition.signal }
+        end
+        get_default_client.publish queue: "splash.#{hostname}.input", message: order.to_yaml
+        lock.synchronize { condition.wait(lock) }
+        splash_exit case: :quiet_exit
+      rescue Interrupt
+        splash_exit status: :error, case: :interrupt, more: "Ping Command"
+      end
+    end
+
+  end
+
+end

data/lib/splash/cli/documentation.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+module CLISplash
+
+  class Documentation < Thor
+    include Splash::Config
+    include Splash::Exiter
+
+
+    desc "readme", "Display README file"
+    option :formatted, :type => :boolean, :default => true
+    def readme
+      filename = search_file_in_gem("prometheus-splash","README.md")
+
+      if options[:formatted] then
+        content = TTY::Markdown.parse_file(filename)
+      else
+        conten = File::readlines(filename).join
+      end
+      pager = TTY::Pager.new
+      pager.page(content)
+      splash_exit case: :quiet_exit
+    end
+  end
+end

data/lib/splash/cli/logs.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+module CLISplash
+
+  class Logs < Thor
+    include Splash::Config
+    include Splash::Exiter
+
+
+    desc "analyse", "analyze logs in config"
+    def analyse
+      results = Splash::LogScanner::new
+      res = results.analyse
+      puts "SPlash Configured logs status :"
+      full_status = true
+      results.output.each do |result|
+        status = (result[:status] == :clean)? "OK": "KO"
+        puts " * Log : #{result[:log]} : [#{status}]"
+        puts "   - Detected pattern : #{result[:pattern]}"
+        puts "   - detailled Status : #{result[:status].to_s}"
+        puts "     count = #{result[:count]}" if result[:status] == :matched
+        puts "     nb lines = #{result[:lines]}" if result[:status] != :missing
+        full_status = false unless result[:status] == :clean
+      end
+      display_status = (full_status)? "OK": "KO"
+      puts "Global Status : [#{display_status}]"
+      splash_exit case: :quiet_exit
+    end
+
+    desc "monitor", "monitor logs in config"
+    def monitor
+      result = Splash::LogScanner::new
+      result.analyse
+      result.notify
+      splash_exit result.notify
+
+    end
+
+    desc "show LOG", "show configured log monitoring for LOG"
+    def show(log)
+      log_record_set = get_config.logs.select{|item| item[:log] == log }
+      unless log_record_set.empty? then
+        record = log_record_set.first
+        puts "Splash log monitor : #{record[:log]}"
+        puts "  ->   pattern : /#{record[:pattern]}/"
+        splash_exit case: :quiet_exit
+    else
+        splash_exit case: :not_found, :more => "log not configured"
+      end
+    end
+
+    desc "list", "Show configured logs monitoring"
+    long_desc <<-LONGDESC
+    Show configured logs monitoring
+    with --detail, show logs monitor details
+    LONGDESC
+    option :detail, :type => :boolean
+    def list
+      puts "Splash configured log monitoring :"
+      log_record_set = get_config.logs
+      puts 'No configured commands found' if log_record_set.empty?
+      log_record_set.each do |record|
+        puts " *  log monitor : #{record[:log]}"
+        if options[:detail] then
+          puts "  ->   pattern : /#{record[:pattern]}/"
+        end
+      end
+      splash_exit case: :quiet_exit
+    end
+
+  end
+
+end

data/lib/splash/commands.rb

@@ -1,20 +1,17 @@
-require 'open3'
-require 'date'
-require 'socket'
-
+# coding: utf-8
 module Splash
   class CommandWrapper
     include Splash::Templates
     include Splash::Config
     include Splash::Helpers
     include Splash::Backends
+    include Splash::Exiter
 
     def initialize(name)
       @config  = get_config
       @name = name
       unless @config.commands.keys.include? @name.to_sym then
-        $stderr.puts "Splash : command #{@name} is not defined in configuration"
-        exit 40
+        splash_exit case: :not_found, more: "command #{@name} is not defined in configuration"
       end
       @registry = Prometheus::Client.registry
       @url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
@@ -26,26 +23,25 @@ module Splash
 
     def ack
       puts "Sending ack for command : '#{@name}'"
-      notify(0)
-      exit 0
+      notify(0,0)
     end
 
     def notify(value,time)
       unless verify_service host: @config.prometheus_pushgateway_host ,port: @config.prometheus_pushgateway_port then
-        $stderr.puts "Prometheus PushGateway Service IS NOT running"
-        $stderr.puts "Exit without notification."
-        exit 30
+        return { :case => :service_dependence_missing, :more => "Prometheus Notification not send."}
       end
       @metric_exitcode.set(value)
       @metric_time.set(time)
       hostname = Socket.gethostname
       Prometheus::Client::Push.new(@name, hostname, @url).add(@registry)
       puts " * Prometheus Gateway notified."
+      return { :case => :quiet_exit}
     end
 
 
     def call_and_notify(options)
       puts "Executing command : '#{@name}' "
+      acase = { :case => :quiet_exit }
       start = Time.now
       start_date = DateTime.now.to_s
       unless options[:trace] then
@@ -89,7 +85,7 @@ module Splash
 
       puts "  => exitcode #{exit_code}"
       if options[:notify] then
-        notify(exit_code,time.to_i)
+        acase = notify(exit_code,time.to_i)
       else
         puts " * Without Prometheus notification"
       end
@@ -103,7 +99,7 @@ module Splash
             @name = on_failure.to_s
             call_and_notify options
           else
-            $stderr.puts "on_failure call error : configuration mistake : #{on_failure} command inexistant."
+            acase = { :case => :configuration_error , :more => "on_failure call error : #{on_failure} command inexistant."}
           end
         end
         if on_success and exit_code == 0 then
@@ -118,8 +114,7 @@ module Splash
       else
         puts " * Without callbacks sequences"
       end
-
-      exit exit_code
+      return acase
     end
   end
 end