prometheus-splash 0.7.0 → 0.8.4

data/config/splash.yml

@@ -2,6 +2,9 @@
 :splash:
 
 ### Main Configuration
+  :paths:
+    :pid_path: /var/run/splash
+    :trace_path: /var/run/splash/traces
   :loggers:
     :level: :info
     :daemon:
@@ -23,6 +26,16 @@
 #        :port: 6379
 #        #:auth: "mykey"
 #        :base: 1
+      :transfers_trace:
+          :type: :file
+          :path: /var/run/splash/transfers
+      :logs_trace:
+          :type: :file
+          :path: /var/run/splash/logs
+      :process_trace:
+          :type: :file
+          :path: /var/run/splash/process
+
   :transports:
     :active: :rabbitmq
     :rabbitmq:
@@ -39,16 +52,14 @@
     :procmon_scheduling:
       :every: 20s
     :process_name: "Splash : daemon."
-    :paths:
-      :pid_path: /var/run/splash
-      :trace_path: /var/run/splash/traces
     :files:
       :stdout_trace: stdout.txt
       :stderr_trace: stderr.txt
       :pid_file: splash.pid
   :prometheus:
-    :pushgateway: 'http://localhost:9091/'
-    :url: 'http://localhost:9090/'
+    :pushgateway: 'http://localhost:9091'
+    :url: 'http://localhost:9090'
+    :alertmanager: 'http://localhost:9093'
   :webadmin:
     :port: 9234
     :ip: 127.0.0.1
@@ -117,15 +128,21 @@
     - :label: :log_app_1
       :log: /tmp/test
       :pattern: ERROR
+      :retention:
+        :hours: 5
     - :label: :log_app_2
       :log: /tmp/test2
       :pattern: ERROR
+      :retention:
+        :hours: 5
 
 ### configuration of monitored processes
   :processes:
     - :process: cron
       :patterns:
         - cron
+      :retention:
+        :hours: 5
 
 
 ###
@@ -175,4 +192,27 @@
         - :step: exec echo3
           :command: :echo3
 
+### Transfers
+  :transfers:
+    - :name: :transfer_text
+      :desc: "List of text files"
+      :pattern: '*.txt'
+      :backup: true
+      :type: :push
+      :retention:
+        :hours: 1
+      :local:
+        :path: /tmp/transferts
+        :user: root
+      :remote:
+        :user: root
+        :host: localhost
+        :path: /tmp/
+      :post:
+        :remote_command: 'ls'
+
+
+
+
+
 ###

data/lib/splash/backends.rb

@@ -11,8 +11,9 @@ module Splash
 
     # factory for backend
     # @param [Symbol] store the name of the store actually in [:execution_trace]
-    # @return [Splash::Backends::<Type>|Hash] with type in [:redis,:file] or Exiter case :configuration_error 
+    # @return [Splash::Backends::<Type>|Hash] with type in [:redis,:file] or Exiter case :configuration_error
     def get_backend(store)
+      splash_exit case: :configuration_error, more: "backend definition failure" if get_config[:backends][:stores][store].nil?
       backend = get_config[:backends][:stores][store][:type].to_s
       aclass = "Splash::Backends::#{backend.capitalize}"
       begin
@@ -22,5 +23,11 @@ module Splash
       end
     end
 
+    # return list of configured backand
+    # @return [Hash] the backends hash list/structure
+    def list_backends
+      return get_config[:backends][:stores]
+    end
+
   end
 end

data/lib/splash/backends/file.rb

@@ -54,7 +54,7 @@ module Splash
       # @option options [Symbol] :key the name of the record
       # @return [Boolean] status of the operation
       def del(options)
-        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if File.exist?("#{@path}/#{suffix_trace(options[:key])}")
+        ::File.unlink("#{@path}/#{suffix_trace(options[:key])}") if ::File.exist?("#{@path}/#{suffix_trace(options[:key])}")
       end
 
       # verifiy a specific record existance

data/lib/splash/cli.rb

@@ -43,6 +43,7 @@ class CLI < Thor
   subcommand "documentation", Documentation
   desc "webadmin SUBCOMMAND ...ARGS", "Splash Webadmin daemon controller"
   subcommand "webadmin", WebAdmin
-
+  desc "transfers SUBCOMMAND ...ARGS", "Managing transfers"
+  subcommand "transfers", Transfers
 
 end

data/lib/splash/cli/commands.rb

@@ -15,7 +15,7 @@ module CLISplash
 
 
     # Thor method : execution of command
-    desc "execute NAME", "run for command/sequence or ack result"
+    desc "execute COMMAND", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
     execute command or sequence or ack result\n
     with --no-trace prevent storing execution trace in configured backend (see config file)\n
@@ -79,7 +79,7 @@ module CLISplash
 
 
     # Thor method : scheduling commands
-    desc "schedule NAME", "Schedule excution of command on Splash daemon"
+    desc "schedule COMMAND", "Schedule excution of command on Splash daemon"
     long_desc <<-LONGDESC
     Schedule excution of command on Splash daemon\n
     with --hostname, Schedule on an other Splash daemon via transport\n
@@ -93,6 +93,9 @@ module CLISplash
     option :at, :type => :string
     option :in, :type => :string
     def schedule(name)
+      unless is_root? then
+        splash_exit case: :not_root, :more => "Command scheduling"
+      end
       log = get_logger
       log.level = :fatal if options[:quiet]
       hostname = (options[:hostname])? options[:hostname] : Socket.gethostname
@@ -122,13 +125,16 @@ module CLISplash
     end
 
     # Thor method : getting a treeview of sequence of commands
-    desc "treeview", "Show commands sequence tree"
+    desc "treeview COMMAND", "Show commands sequence tree"
     long_desc <<-LONGDESC
     Show commands sequence tree\n
     with --hostname, ask other Splash daemon via transport\n
     LONGDESC
     option :hostname, :type => :string,  :aliases => "-H"
     def treeview(command)
+      unless is_root? then
+        splash_exit case: :not_root, :more => "Command treeview"
+      end
       depht = 0
       log  = get_logger
       if options[:hostname] then
@@ -179,6 +185,9 @@ module CLISplash
     option :detail, :type => :boolean,  :aliases => "-D"
     option :hostname, :type => :string,  :aliases => "-H"
     def list
+      unless is_root? then
+        splash_exit case: :not_root, :more => "Command list"
+      end
       log = get_logger
       list = {}
       if options[:hostname] then
@@ -227,6 +236,9 @@ module CLISplash
     LONGDESC
     option :hostname, :type => :string,  :aliases => "-H"
     def show(command)
+      unless is_root? then
+        splash_exit case: :not_root, :more => "Command show specifications"
+      end
       log = get_logger
       list = {}
       if options[:hostname] then
@@ -265,14 +277,71 @@ module CLISplash
       end
     end
 
-    # Thor method : getting information on the last execution of a command
-    desc "lastrun COMMAND", "Show last running result for specific configured command COMMAND"
+
+
+    # Thor method : show commands executions  history
+    long_desc <<-LONGDESC
+    show commands executions history for LABEL\n
+    LONGDESC
+    option :table, :type => :boolean,  :aliases => "-t"
+    desc "history COMMAND", "show commands executions history"
+    def history(command)
+      if is_root? then
+        log = get_logger
+        log.info "Command : #{command}"
+        config = get_config
+        if options[:table] then
+          table = TTY::Table.new do |t|
+            t << ["Start Date","Status", "end_date", "Execution time","STDOUT empty ? ", "STDERR empty ? "]
+            t << ['','','','','','']
+            CmdRecords::new(command).get_all_records.each do |item|
+              record =item.keys.first
+              value=item[record]
+              t << [record, value[:status].to_s,
+                            value[:end_date],
+                            value[:exec_time],
+                            value[:stdout].empty?,
+                            value[:stdout].empty?]
+            end
+          end
+          if check_unicode_term  then
+            puts table.render(:unicode)
+          else
+            puts table.render(:ascii)
+          end
+
+        else
+          CmdRecords::new(command).get_all_records.each do |item|
+            record =item.keys.first
+            value=item[record]
+            log.item record
+            log.arrow "Status : #{value[:status].to_s}"
+            log.arrow "End date : #{value[:end_date]}"
+            log.arrow "Execution time : #{value[:exec_time]}"
+            log.arrow "STDOUT empty ?  : #{value[:stdout].empty?}"
+            log.arrow "STDERR empty ?  : #{value[:stderr].empty?}"
+          end
+        end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Command execution history"
+      end
+    end
+
+    # Thor method : getting information on one specific execution of a command
+    desc "get_result COMMAND", "Show running result for specific configured command COMMAND"
     long_desc <<-LONGDESC
-    Show last running result for specific configured command COMMAND\n
+    Show specific running result for specific configured command COMMAND\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
+    with --date <DATE>, a date format string (same as in history ouput)
+
     LONGDESC
     option :hostname, :type => :string,  :aliases => "-H"
-    def lastrun(command)
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(command)
+      unless is_root? then
+        splash_exit case: :not_root, :more => "Command specific execution report"
+      end
       log = get_logger
       backend = get_backend :execution_trace
       redis = (backend.class == Splash::Backends::Redis)? true : false
@@ -294,19 +363,32 @@ module CLISplash
           tp = Template::new(
               list_token: get_config.execution_template_tokens,
               template_file: get_config.execution_template_path)
-          tp.map YAML::load(res)
-          log.flat tp.output
+          if options[:date] then
+            prov =  YAML::load(res).select{|key,value| key.keys.first == options[:date]}.first
+          else
+            prov = YAML::load(res).last
+          end
+          if prov.nil? then
+            log.ko "Command not runned one this date or date misformatted."
+          else
+            tp.map prov.values.first
+            log.flat tp.output
+          end
         else
           log.ko "Command not already runned."
         end
         splash_exit case: :quiet_exit
       else
-        splash_exit case: :not_found, :more => "Command report never runned remotly" if options[:hostname]
+        if options[:hostname]
+            splash_exit case: :not_found, :more => "Command never runned remotly"
+          else
+            splash_exit case: :not_found, :more => "Command never runned"
+          end
       end
     end
 
     # Thor method : getting the list of avaibles executions reports
-    desc "getreportlist", "list all executions report results "
+    desc "reportlist", "list all executions report results "
     long_desc <<-LONGDESC
     list all executions report results\n
     with --pattern <SEARCH>, search type string, wilcard * (group) ? (char)\n
@@ -319,7 +401,10 @@ module CLISplash
     option :hostname, :type => :string,  :aliases => "-H"
     option :all, :type => :boolean, :negate => false,  :aliases => "-A"
     option :detail, :type => :boolean,  :aliases => "-D"
-    def getreportlist
+    def reportlist
+      unless is_root? then
+        splash_exit case: :not_root, :more => "Command execution report list"
+      end
       log = get_logger
       options[:hostname] = Socket.gethostname if options[:hostname] == 'hostname'
       if options[:hostname] and options[:all] then
@@ -355,10 +440,9 @@ module CLISplash
           req = { :key => command }
           req[:hostname] = host if options[:all]
           res = YAML::load(backend.get(req))
-          log.arrow "Status : #{res[:status]}"
-          log.arrow "Start date : #{res[:start_date]}"
-          log.arrow "End date : #{res[:end_date]}"
-          log.arrow "Execution time : #{res[:exec_time]}"
+          res.each do |record|
+            log.arrow "#{record.keys.first} : #{record[record.keys.first][:status]}"
+          end
         end
       end
       splash_exit case: :quiet_exit

data/lib/splash/cli/config.rb

@@ -9,6 +9,7 @@ module CLISplash
     include Splash::Helpers
     include Splash::Exiter
     include Splash::Loggers
+    include Splash::Backends
 
     # Thor method : running of Splash setup
     desc "setup", "Setup installation fo Splash"
@@ -49,8 +50,18 @@ module CLISplash
 
     # Thor method : flushing configured backend
     desc "flushbackend", "Flush configured backend"
+    option :name, :type => :string,  :aliases => "-N"
     def flushbackend
-      acase = run_as_root :flush_backend
+      if options[:name] then
+        acase = run_as_root :flush_backend, options
+      else
+        return_cases = {}
+        list_backends.each do |key,value|
+          return_cases[key] = run_as_root :flush_backend, { :name => key }
+        end
+        errors = return_cases.select {|key,value| value[:case] != :quiet_exit}.keys
+        acase = (errors.empty?)? {:case => :quiet_exit, :more => "All backends flushed successfully"}: {:case => :configuration_error, :more => "Backends #{errors.join(',')} flushing failed"}
+      end
       splash_exit acase
     end
 

data/lib/splash/cli/daemon.rb

@@ -74,7 +74,47 @@ module CLISplash
           splash_exit case: :quiet_exit
         end
       rescue Interrupt
-        splash_exit status: :error, case: :interrupt, more: "Ping Command"
+        splash_exit status: :error, case: :interrupt, more: "ping Command"
+      end
+    end
+
+    # Thor method : sending get_jobs verb over transport in the input queue of Splashd
+    desc "getjobs", "send a get_jobs verb to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
+    def getjobs(hostname=Socket.gethostname)
+      log = get_logger
+      log.info "ctrl+c for interrupt"
+      begin
+        transport = get_default_client
+        if transport.class == Hash  and transport.include? :case then
+          splash_exit transport
+        else
+          log.receive transport.execute({ :verb => :get_jobs,
+                                  :return_to => "splash.#{Socket.gethostname}.returncli",
+                                  :queue => "splash.#{hostname}.input" })
+          splash_exit case: :quiet_exit
+        end
+      rescue Interrupt
+        splash_exit status: :error, case: :interrupt, more: "getjobs Command"
+      end
+    end
+
+    # Thor method : sending reset verb over transport in the input queue of Splashd
+    desc "getjobs", "send a reset verb to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
+    def reset(hostname=Socket.gethostname)
+      log = get_logger
+      log.info "ctrl+c for interrupt"
+      begin
+        transport = get_default_client
+        if transport.class == Hash  and transport.include? :case then
+          splash_exit transport
+        else
+          log.receive transport.execute({ :verb => :reset,
+                                  :return_to => "splash.#{Socket.gethostname}.returncli",
+                                  :queue => "splash.#{hostname}.input" })
+          splash_exit case: :quiet_exit
+        end
+      rescue Interrupt
+        splash_exit status: :error, case: :interrupt, more: "reset Command"
       end
     end
 

data/lib/splash/cli/logs.rb

@@ -12,61 +12,76 @@ module CLISplash
     # Thor method : running Splash configured logs monitors analyse
     desc "analyse", "analyze logs defined in Splash config"
     def analyse
-      log  = get_logger
-      results = LogScanner::new
-      res = results.analyse
-      log.info "SPlash Configured log monitors :"
-      full_status = true
-      results.output.each do |result|
-        if result[:status] == :clean then
-          log.ok "Log : #{result[:log]} with label : #{result[:label]} : no errors"
-          log.item "Detected pattern : #{result[:pattern]}"
-          log.item "Nb lines = #{result[:lines]}"
-        elsif result[:status] == :missing then
-          log.ko "Log : #{result[:log]} with label : #{result[:label]} : missing !"
-          log.item "Detected pattern : #{result[:pattern]}"
-        else
-          log.ko "Log : #{result[:log]} with label : #{result[:label]} : #{result[:count]} errors"
-          log.item "Detected pattern : #{result[:pattern]}"
-          log.item "Nb lines = #{result[:lines]}"
-        end
+      if is_root? then
+        log  = get_logger
+        results = LogScanner::new
+        res = results.analyse
+        log.info "SPlash Configured log monitors :"
+        full_status = true
+        results.output.each do |result|
+          if result[:status] == :clean then
+            log.ok "Log : #{result[:log]} with label : #{result[:label]} : no errors"
+            log.item "Detected pattern : #{result[:pattern]}"
+            log.item "Nb lines = #{result[:lines]}"
+          elsif result[:status] == :missing then
+            log.ko "Log : #{result[:log]} with label : #{result[:label]} : missing !"
+            log.item "Detected pattern : #{result[:pattern]}"
+          else
+            log.ko "Log : #{result[:log]} with label : #{result[:label]} : #{result[:count]} errors"
+            log.item "Detected pattern : #{result[:pattern]}"
+            log.item "Nb lines = #{result[:lines]}"
+          end
 
-        full_status = false unless result[:status] == :clean
-      end
+          full_status = false unless result[:status] == :clean
+        end
 
-      if full_status then
-        log.ok "Global status : no error found"
+        if full_status then
+          log.ok "Global status : no error found"
+        else
+          log.error "Global status : some error found"
+        end
+        splash_exit case: :quiet_exit
       else
-        log.error "Global status : some error found"
+        splash_exit case: :not_root, :more => "Log analysis"
       end
-      splash_exit case: :quiet_exit
     end
 
 
     # Thor method : running Splash configured logs monitors analyse and sending to Prometheus Pushgateway
     desc "monitor", "monitor logs defined in Splash config"
     def monitor
-      log = get_logger
-      log.level = :fatal if options[:quiet]
-      result = LogScanner::new
-      result.analyse
-      splash_exit result.notify
+      if is_root? then
+        log = get_logger
+        log.level = :fatal if options[:quiet]
+        result = LogScanner::new
+        result.analyse
+        splash_exit result.notify
+      else
+        splash_exit case: :not_root, :more => "Log analysis"
+      end
 
     end
 
+
+
+
     # Thor method : display a specific Splash configured log monitor
-    desc "show LOG", "show Splash configured log monitoring for LOG"
+    desc "show LABEL", "show Splash configured log monitoring for LOG"
     def show(logrecord)
-      log = get_logger
-      log_record_set = get_config.logs.select{|item| item[:log] == logrecord or item[:label] == logrecord.to_sym}
-      unless log_record_set.empty? then
-        record = log_record_set.first
-        log.info "Splash log monitor : #{record[:log]}"
-        log.item "pattern : /#{record[:pattern]}/"
-        log.item "label : #{record[:label]}"
-        splash_exit case: :quiet_exit
+      if is_root? then
+        log = get_logger
+        log_record_set = get_config.logs.select{|item| item[:log] == logrecord or item[:label] == logrecord.to_sym}
+        unless log_record_set.empty? then
+          record = log_record_set.first
+          log.info "Splash log monitor : #{record[:log]}"
+          log.item "pattern : /#{record[:pattern]}/"
+          log.item "label : #{record[:label]}"
+          splash_exit case: :quiet_exit
+        else
+          splash_exit case: :not_found, :more => "log not configured"
+        end
       else
-        splash_exit case: :not_found, :more => "log not configured"
+        splash_exit case: :not_root, :more => "Log analysis"
       end
     end
 
@@ -78,17 +93,98 @@ module CLISplash
     LONGDESC
     option :detail, :type => :boolean,  :aliases => "-D"
     def list
-      log = get_logger
-      log.info "Splash configured log monitoring :"
-      log_record_set = get_config.logs
-      log.ko 'No configured commands found' if log_record_set.empty?
-      log_record_set.each do |record|
-        log.item "log monitor : #{record[:log]} label : #{record[:label]}"
-        if options[:detail] then
-          log.arrow "pattern : /#{record[:pattern]}/"
+      if is_root? then
+        log = get_logger
+        log.info "Splash configured log monitoring :"
+        log_record_set = get_config.logs
+        log.ko 'No configured commands found' if log_record_set.empty?
+        log_record_set.each do |record|
+          log.item "log monitor : #{record[:log]} label : #{record[:label]}"
+          if options[:detail] then
+            log.arrow "pattern : /#{record[:pattern]}/"
+          end
         end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Log analysis"
+      end
+    end
+
+    # Thor method : display the full list of Splash configured log monitors
+    desc "get_result LABEL", "Get last or specific log monitoring report"
+    long_desc <<-LONGDESC
+    Get last or specific log monitoring report\n
+    with --date <DATE>, a date format string (same as in history ouput)
+    LONGDESC
+    option :date, :type => :string,  :aliases => "-D"
+    def get_result(label)
+      if is_root? then
+        log = get_logger
+        log.info "Log : #{label}"
+        config = get_config
+        records = LogsRecords::new(label).get_all_records
+        if options[:date] then
+          wanted = records.select{|key,value| key.keys.first == options[:date]}.first
+        else
+          wanted = records.last
+        end
+        if wanted.nil? then
+          splash_exit case: :not_found, more: "Log never monitored"
+        else
+          record =wanted.keys.first
+          value=wanted[record]
+          log.item record
+          log.arrow "Status : #{value[:status].to_s}"
+          log.arrow "nb files : #{value[:errors]}"
+          log.arrow "nb lines : #{value[:lines]}"
+        end
+      else
+        splash_exit case: :not_root, :more => "Log get result"
+      end
+    end
+
+    # Thor method : show logs monitoring history
+    long_desc <<-LONGDESC
+    show logs monitoring history for LABEL\n
+    LONGDESC
+    option :table, :type => :boolean,  :aliases => "-t"
+    desc "history LABEL", "show logs monitoring history"
+    def history(label)
+      if is_root? then
+        log = get_logger
+        log.info "Log : #{label}"
+        config = get_config
+        if options[:table] then
+          table = TTY::Table.new do |t|
+            t << ["Start Date", "File","Status", "Nb errors", "Nb lines"]
+            t << ['','','','','']
+            LogsRecords::new(label).get_all_records.each do |item|
+              record =item.keys.first
+              value=item[record]
+
+              t << [record, value[:file], value[:status].to_s, value[:errors], value[:lines]]
+            end
+          end
+          if check_unicode_term  then
+            puts table.render(:unicode)
+          else
+            puts table.render(:ascii)
+          end
+
+        else
+          LogsRecords::new(label).get_all_records.each do |item|
+            record =item.keys.first
+            value=item[record]
+            log.item record
+            log.arrow "Status : #{value[:status].to_s}"
+            log.arrow "nb files : #{value[:errors]}"
+            log.arrow "nb lines : #{value[:lines]}"
+          end
+        end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Log analysis"
       end
-      splash_exit case: :quiet_exit
     end
 
   end