prometheus-splash 0.0.3 → 0.1.0

data/bin/splash

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby -W:no-deprecated
-
+require 'socket'
+require 'yaml'
+require 'thread'
 
 begin
   require 'prometheus/client'
@@ -20,6 +22,7 @@ require 'splash/helpers'
 require 'splash/config'
 require 'splash/templates'
 require 'splash/backends'
+require 'splash/transports'
 
 require 'splash/commands'
 require 'splash/logs'
@@ -38,21 +41,24 @@ module CLISplash
     include Splash::Config
     include Splash::Backends
 
-    desc "run NAME", "run for command/sequence or ack result"
+    desc "execute NAME", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
-    Running  command or sequence or ack result
-    with --no-trace prevent storing execution trace in TRACE_PATH (see config file)
+    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
-    def wrap(name)
+    option :callback, :type => :boolean, :default => true
+    def execute(name)
       if is_root? then
         command =  Splash::CommandWrapper::new(name)
         command.ack if options[:ack]
-        command.call_and_notify trace: options[:trace], notify: options[:notify]
+        command.call_and_notify trace: options[:trace], notify: options[:notify], callback: options[:callback]
       else
         $stderr.puts "Command wrapping need to be run as root"
         exit 60
@@ -124,14 +130,24 @@ module CLISplash
 
 
     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
+        $stderr.puts "Remote execution report request only possible with Redis backend"
+      end
       list = get_config.commands
       if list.keys.include? command.to_sym then
         print "Splash command #{command} previous execution report:\n\n"
-        backend = get_backend :execution_trace
-        key = "#{command}_trace.last"
-        if backend.exist? key: key then
-          print backend.get key: key
+        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
@@ -141,11 +157,58 @@ module CLISplash
       end
     end
 
+    desc "getreportlist COMMAND", "list all executions report results "
+    long_desc <<-LONGDESC
+    Show configured commands
+    with --pattern <SEARCH>, search type string, wilcard * (group) ? (char)
+    with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
+    with --all, get all execution report for all servers (only with Redis backend configured)
+    --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
+        $stderr.puts "--all option imcompatible with --hostname"
+        exit 40
+      end
+      backend = get_backend :execution_trace
+      redis = (backend.class == Splash::Backends::Redis)? true : false
+      if not redis and (options[:hostname] or options[:all]) then
+        $stderr.puts "Remote execution report request only possible with Redis backend"
+        exit 40
+      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
+    end
+
+
+
   end
 
 
+
+
   class CLIController < Thor
     include Splash::LogsMonitor::DaemonController
+    include Splash::Transports
 
     option :foreground, :type => :boolean
     desc "start", "Starting Logs Monitor Daemon"
@@ -166,6 +229,26 @@ module CLISplash
       exit errorcode
     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) }
+      rescue Interrupt
+        puts "Splash : ping : Interrupted by user. "
+        exit 33
+      end
+    end
 
   end
 
@@ -177,6 +260,11 @@ module CLISplash
     include Splash::Helpers
 
     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
       errorcode = run_as_root :setupsplash
       exit errorcode

data/config/splash.yml

@@ -5,19 +5,7 @@
   :templates:
     :execution:
       :path: /etc/splash_execution_report.tpl
-      :tokens:
-        - :date
-        - :cmd_name
-        - :cmd_line
-        - :stdout
-        - :stderr
-        - :desc
-        - :status
-        - :exec_time
   :backends:
-    :list:
-      - :file
-      - :redis
     :stores:
       :execution_trace:
           :type: :file
@@ -94,5 +82,5 @@
   :logs:
     - :log: /tmp/test
       :pattern: ERROR
-    - :log: /var/log/message
-      :pattern: error
+    - :log: /tmp/test2
+      :pattern: ERROR

data/lib/splash/backends/file.rb

@@ -8,25 +8,31 @@ module Splash
       end
 
       def list(pattern='*')
-         return Dir.glob(pattern)
+        pattern = suffix_trace(pattern)
+        return Dir.glob("#{@path}/#{pattern}").map{|item| ::File.basename(item,".trace") }
       end
 
       def get(options)
-        return ::File.readlines("#{@path}/#{options[:key]}").join
+        return ::File.readlines("#{@path}/#{suffix_trace(options[:key])}").join
       end
 
       def put(options)
-        ::File.open("#{@path}/#{options[:key]}", 'w') { |file|
+        ::File.open("#{@path}/#{suffix_trace(options[:key])}", 'w') { |file|
           file.write options[:value]
         }
       end
 
       def del(options)
-        ::File.unlink("#{@path}/#{options[:key]}") if File.exist?("#{@path}/#{options[:key]}")
+        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if File.exist?("#{@path}/#{suffix_trace(options[:key])}")
       end
 
       def exist?(options)
-        return ::File.exist?("#{@path}/#{options[:key]}")
+        return ::File.exist?("#{@path}/#{suffix_trace(options[:key])}")
+      end
+
+      private
+      def suffix_trace(astring)
+        return "#{astring}.trace"
       end
 
     end

data/lib/splash/backends/redis.rb

@@ -1,30 +1,39 @@
 require "redis"
+require "socket"
 
 module Splash
   module Backends
     class Redis
       include Splash::Config
       def initialize(store)
+        @hostname = Socket.gethostname
         @config = get_config[:backends][:stores][store]
         @store = ::Redis.new :host => @config[:host], :port => @config[:port], :db => @config[:base].to_i
         @redis_cli_cmd = `which redis-cli`
         @store.auth(@config[:auth]) if @config[:auth]
       end
 
-      def list(pattern='*')
-         return @store.keys pattern
+      def list(pattern='*', hostname = @hostname)
+         return @store.keys("#{hostname}##{pattern}").map{|item| item = remove_hostname(item)}
+      end
+
+      def listall(pattern='*')
+         return @store.keys(pattern)
       end
 
       def get(options)
-        return @store.get(options[:key])
+        hostname = (options[:hostname])? options[:hostname] : @hostname
+        return @store.get(prefix_hostname(options[:key],hostname))
       end
 
       def put(options)
-        @store.set options[:key], options[:value]
+        hostname = (options[:hostname])? options[:hostname] : @hostname
+        @store.set prefix_hostname(options[:key],hostname), options[:value]
       end
 
       def del(options)
-        @store.del options[:key]
+        hostname = (options[:hostname])? options[:hostname] : @hostname
+        @store.del prefix_hostname(options[:key],hostname)
       end
 
       def flush
@@ -33,7 +42,20 @@ module Splash
       end
 
       def exist?(options)
-        return ( not @store.get(options[:key]).nil?)
+        hostname = (options[:hostname])? options[:hostname] : @hostname
+        return ( not @store.get(prefix_hostname(options[:key],hostname)).nil?)
+      end
+
+      private
+      def prefix_hostname(key,hostname)
+        return "#{hostname}##{key}"
+      end
+
+
+      def remove_hostname(astring)
+        result = astring.split("#")
+        result.shift
+        return result.join("#")
       end
 
     end

data/lib/splash/commands.rb

@@ -47,6 +47,7 @@ module Splash
     def call_and_notify(options)
       puts "Executing command : '#{@name}' "
       start = Time.now
+      start_date = DateTime.now.to_s
       unless options[:trace] then
         puts " * Traceless execution"
         if @config.commands[@name.to_sym][:user] then
@@ -70,7 +71,8 @@ module Splash
             list_token: @config.execution_template_tokens,
             template_file: @config.execution_template_path)
 
-        tp.date = DateTime.now.to_s
+        tp.start_date = start_date
+        tp.end_date = DateTime.now.to_s
         tp.cmd_name = @name
         tp.cmd_line = @config.commands[@name.to_sym][:command]
         tp.desc = @config.commands[@name.to_sym][:desc]
@@ -79,7 +81,7 @@ module Splash
         tp.stderr = stderr
         tp.exec_time = time.to_s
         backend = get_backend :execution_trace
-        key = "#{@name}_trace.last"
+        key = @name
         backend.put key: key, value: tp.output
         exit_code = status.exitstatus
 
@@ -91,29 +93,32 @@ module Splash
       else
         puts " * Without Prometheus notification"
       end
-      on_failure = (@config.commands[@name.to_sym][:on_failure])? @config.commands[@name.to_sym][:on_failure] : false
-      on_success = (@config.commands[@name.to_sym][:on_success])? @config.commands[@name.to_sym][:on_success] : false
+      if options[:callback] then
+        on_failure = (@config.commands[@name.to_sym][:on_failure])? @config.commands[@name.to_sym][:on_failure] : false
+        on_success = (@config.commands[@name.to_sym][:on_success])? @config.commands[@name.to_sym][:on_success] : false
 
-      if on_failure and exit_code > 0 then
-        puts " * On failure callback : #{on_failure}"
-        if @config.commands.keys.include?  on_failure then
-          @name = on_failure.to_s
-          call_and_notify options
-        else
-          $stderr.puts "on_failure call error : configuration mistake : #{on_failure} command inexistant."
+        if on_failure and exit_code > 0 then
+          puts " * On failure callback : #{on_failure}"
+          if @config.commands.keys.include?  on_failure then
+            @name = on_failure.to_s
+            call_and_notify options
+          else
+            $stderr.puts "on_failure call error : configuration mistake : #{on_failure} command inexistant."
+          end
         end
-      end
-      if on_success and exit_code == 0 then
-        puts " * On success callback : #{on_success}"
-        if @config.commands.keys.include?  on_success then
-          @name = on_success.to_s
-          call_and_notify options
-        else
-          $stderr.puts "on_success call error : configuration mistake : #{on_success} command inexistant."
+        if on_success and exit_code == 0 then
+          puts " * On success callback : #{on_success}"
+          if @config.commands.keys.include?  on_success then
+            @name = on_success.to_s
+            call_and_notify options
+          else
+            $stderr.puts "on_success call error : configuration mistake : #{on_success} command inexistant."
+          end
         end
+      else
+        puts " * Without callbacks sequences"
       end
 
-
       exit exit_code
     end
   end

data/lib/splash/config.rb

@@ -18,7 +18,7 @@ module Splash
         self[:prometheus_pushgateway_port] = (config_from_file[:prometheus][:pushgateway][:port])? config_from_file[:prometheus][:pushgateway][:port] : PROMETHEUS_PUSHGATEWAY_PORT
         self[:daemon_process_name] = (config_from_file[:daemon][:process_name])? config_from_file[:daemon][:process_name] : DAEMON_PROCESS_NAME
         self[:daemon_logmon_scheduling] = (config_from_file[:daemon][:logmon_scheduling])? config_from_file[:daemon][:logmon_scheduling] : DAEMON_LOGMON_SCHEDULING
-        self[:execution_template_tokens] = (config_from_file[:templates][:execution][:tokens])? config_from_file[:templates][:execution][:tokens] : EXECUTION_TEMPLATE_TOKENS_LIST
+        self[:execution_template_tokens] = EXECUTION_TEMPLATE_TOKENS_LIST
         self[:execution_template_path] = (config_from_file[:templates][:execution][:path])? config_from_file[:templates][:execution][:path] : EXECUTION_TEMPLATE
         self[:pid_path] = (config_from_file[:daemon][:paths][:pid_path])? config_from_file[:daemon][:paths][:pid_path] : DAEMON_PID_PATH
         self[:trace_path] = (config_from_file[:daemon][:paths][:trace_path])? config_from_file[:daemon][:paths][:trace_path] : TRACE_PATH
@@ -58,7 +58,7 @@ module Splash
       end
 
       def transports
-        return self[:transport]
+        return self[:transports]
       end
 
       def daemon_logmon_scheduling
@@ -137,12 +137,16 @@ module Splash
       conf_in_path = search_file_in_gem "prometheus-splash", "config/splash.yml"
       full_res = 0
       puts "Splash -> setup : "
-      print "* Installing Configuration file : #{CONFIG_FILE} : "
-      if install_file source: conf_in_path, target: CONFIG_FILE, mode: "644", owner: Configuration.user_root, group: Configuration.group_root then
-        puts "[OK]"
+      unless options[:preserve] then
+        print "* Installing Configuration file : #{CONFIG_FILE} : "
+        if install_file source: conf_in_path, target: CONFIG_FILE, mode: "644", owner: Configuration.user_root, group: Configuration.group_root then
+          puts "[OK]"
+        else
+          full_res =+ 1
+          puts "[KO]"
+        end
       else
-        full_res =+ 1
-        puts "[KO]"
+        puts "Config file preservation."
       end
       config = get_config
       report_in_path = search_file_in_gem "prometheus-splash", "templates/report.txt"

data/lib/splash/constants.rb

@@ -1,30 +1,50 @@
 module Splash
   module Constants
-    VERSION = "0.0.3"
+    VERSION = "0.1.0"
 
+    # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
+    # the default execution trace_path if backend file
     TRACE_PATH="/var/run/splash"
 
+
+    # default scheduling criteria for log monitoring
     DAEMON_LOGMON_SCHEDULING={ :every => '20s'}
+    # the display name of daemon in proc info (ps/top)
     DAEMON_PROCESS_NAME="Splash : daemon."
+    # the default pid file path
     DAEMON_PID_PATH="/var/run"
+    # the default pid file name
     DAEMON_PID_FILE="splash.pid"
+    # the default sdtout trace file
     DAEMON_STDOUT_TRACE="stdout.txt"
+    # the default sdterr trace file
     DAEMON_STDERR_TRACE="stderr.txt"
 
+    # the Author name
     AUTHOR="Romain GEORGES"
+    # the maintainer mail
     EMAIL = "gems@ultragreen.net"
+    # legal Copyright (c) 2020 Copyright Utragreen All Rights Reserved.
     COPYRIGHT="Ultragreen (c) 2020"
+    # type of licence
     LICENSE="BSD-2-Clause"
 
+    # the default prometheus pushgateway host
     PROMETHEUS_PUSHGATEWAY_HOST = "localhost"
+    # the default prometheus pushgateway port
     PROMETHEUS_PUSHGATEWAY_PORT = "9091"
 
+    # the default path fo execution report template
     EXECUTION_TEMPLATE="/etc/splash_execution_report.tpl"
-    EXECUTION_TEMPLATE_TOKENS_LIST = [:date,:cmd_name,:cmd_line,:stdout,:stderr,:desc,:status,:exec_time]
 
+    # the list of authorized tokens for template, carefull override,
+    EXECUTION_TEMPLATE_TOKENS_LIST = [:end_date,:start_date,:cmd_name,:cmd_line,:stdout,:stderr,:desc,:status,:exec_time]
+
+    # backends default settings
     BACKENDS_STRUCT = { :list => [:file,:redis],
                         :stores => { :execution_trace => { :type => :file, :path => "/var/run/splash" }}}
+    # transports default settings
     TRANSPORTS_STRUCT = { :list => [:rabbitmq],
                         :active => :rabbitmq,
                         :rabbitmq => { :url => 'amqp://localhost/'} }