prometheus-splash 0.7.0 → 0.8.4

data/lib/splash/cli/process.rb

@@ -12,65 +12,77 @@ module CLISplash
     # Thor method : unning Splash configured processes monitors analyse
     desc "analyse", "analyze processes defined in Splash config"
     def analyse
-      log  = get_logger
-      results = ProcessScanner::new
-      res = results.analyse
-      log.info "Splash Configured process records :"
-      full_status = true
-      results.output.each do |result|
-        if result[:status] == :running then
-          log.ok "Process : #{result[:process]} : running"
-          log.item "Detected patterns : "
-          result[:patterns].each do |pattern|
-            log.arrow "/#{pattern}/"
+      if is_root? then
+        log  = get_logger
+        results = ProcessScanner::new
+        res = results.analyse
+        log.info "Splash Configured process records :"
+        full_status = true
+        results.output.each do |result|
+          if result[:status] == :running then
+            log.ok "Process : #{result[:process]} : running"
+            log.item "Detected patterns : "
+            result[:patterns].each do |pattern|
+              log.arrow "/#{pattern}/"
+            end
+            log.item "CPU usage in % : #{result[:cpu]} "
+            log.item "Memory usage in % : #{result[:mem]} "
+          else
+            log.ko "Process : #{result[:process]} : inexistant"
+            log.item "Detected patterns : "
+            result[:patterns].each do |pattern|
+              log.arrow "/#{pattern}/"
+            end
           end
-          log.item "CPU usage in % : #{result[:cpu]} "
-          log.item "Memory usage in % : #{result[:mem]} "
-        else
-          log.ko "Process : #{result[:process]} : inexistant"
-          log.item "Detected patterns : "
-          result[:patterns].each do |pattern|
-            log.arrow "/#{pattern}/"
-          end
-        end
 
-        full_status = false unless result[:status] == :running
-      end
+          full_status = false unless result[:status] == :running
+        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 => "Process analysis"
       end
-      splash_exit case: :quiet_exit
     end
 
 
     # Thor method : running Splash configured processes monitors analyse and sending to Prometheus Pushgateway
     desc "monitor", "monitor processes defined in Splash config"
     def monitor
-      log = get_logger
-      log.level = :fatal if options[:quiet]
-      result = ProcessScanner::new
-      result.analyse
-      splash_exit result.notify
+      if is_root? then
+        log = get_logger
+        log.level = :fatal if options[:quiet]
+        result = ProcessScanner::new
+        result.analyse
+        splash_exit result.notify
+      else
+        splash_exit case: :not_root, :more => "Process analysis"
+      end
     end
 
     # Thor method : display a specific Splash configured process monitor
     desc "show PROCESS", "show Splash configured process record for PROCESS"
     def show(record)
-      log = get_logger
-      process_recordset = get_config.processes.select{|item| item[:process] == record }
-      unless process_recordset.empty? then
-        record = process_recordset.first
-        log.item "Process monitor : #{record[:process]}"
-        log.arrow "patterns :"
-        record[:patterns].each do |pattern|
-          log.flat "   - /#{pattern}/"
+      if is_root? then
+        log = get_logger
+        process_recordset = get_config.processes.select{|item| item[:process] == record }
+        unless process_recordset.empty? then
+          record = process_recordset.first
+          log.item "Process monitor : #{record[:process]}"
+          log.arrow "patterns :"
+          record[:patterns].each do |pattern|
+            log.flat "   - /#{pattern}/"
+          end
+          splash_exit case: :quiet_exit
+        else
+          splash_exit case: :not_found, :more => "Process not configured"
         end
-        splash_exit case: :quiet_exit
       else
-        splash_exit case: :not_found, :more => "Process not configured"
+        splash_exit case: :not_root, :more => "Process analysis"
       end
     end
 
@@ -82,20 +94,101 @@ module CLISplash
     LONGDESC
     option :detail, :type => :boolean,  :aliases => "-D"
     def list
-      log = get_logger
-      log.info "Splash configured process records :"
-      process_recordset = get_config.processes
-      log.ko 'No configured process found' if process_recordset.empty?
-      process_recordset.each do |record|
-        log.item "Process monitor : #{record[:process]}"
-        if options[:detail] then
-          log.arrow "patterns :"
-          record[:patterns].each do |pattern|
-            log.flat "   - /#{pattern}/"
+      if is_root? then
+        log = get_logger
+        log.info "Splash configured process records :"
+        process_recordset = get_config.processes
+        log.ko 'No configured process found' if process_recordset.empty?
+        process_recordset.each do |record|
+          log.item "Process monitor : #{record[:process]}"
+          if options[:detail] then
+            log.arrow "patterns :"
+            record[:patterns].each do |pattern|
+              log.flat "   - /#{pattern}/"
+            end
           end
         end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Process analysis"
+      end
+    end
+
+    # Thor method : display the full list of Splash configured process monitors
+    desc "get_result PROCESS", "Get last or specific process monitoring report"
+    long_desc <<-LONGDESC
+    Get last or specific process 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(process)
+      if is_root? then
+        log = get_logger
+        log.info "Process : #{process}"
+        config = get_config
+        records = ProcessRecords::new(process).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: "Process never monitored"
+        else
+          record =wanted.keys.first
+          value=wanted[record]
+          log.item record
+          log.arrow "Status : #{value[:status].to_s}"
+          log.arrow "CPU Percent : #{value[:cpu_percent]}"
+          log.arrow "MEM Percent : #{value[:mem_percent]}"
+        end
+      else
+        splash_exit case: :not_root, :more => "Process get result"
+      end
+    end
+
+
+    # Thor method : show logs monitoring history
+    long_desc <<-LONGDESC
+    show Process monitoring history for LABEL\n
+    LONGDESC
+    option :table, :type => :boolean,  :aliases => "-t"
+    desc "history PROCESS", "show process monitoring history"
+    def history(process)
+      if is_root? then
+        log = get_logger
+        log.info "Process : #{process}"
+        config = get_config
+        if options[:table] then
+          table = TTY::Table.new do |t|
+            t << ["Start Date", "Status", "CPU Percent", "MEM Percent"]
+            t << ['','','','']
+            ProcessRecords::new(process).get_all_records.each do |item|
+              record =item.keys.first
+              value=item[record]
+              t << [record, value[:status].to_s, value[:cpu_percent], value[:mem_percent]]
+            end
+          end
+          if check_unicode_term  then
+            puts table.render(:unicode)
+          else
+            puts table.render(:ascii)
+          end
+
+        else
+          ProcessRecords::new(process).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 "CPU Percent : #{value[:cpu_percent]}"
+            log.arrow "MEM Percent : #{value[:mem_percent]}"
+          end
+        end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_root, :more => "Process analysis"
       end
-      splash_exit case: :quiet_exit
     end
 
   end

data/lib/splash/cli/transfers.rb

@@ -0,0 +1,213 @@
+# coding: utf-8
+
+# module for all Thor subcommands
+module CLISplash
+
+  # Thor inherited class for transfers management
+  class Transfers < Thor
+    include Splash::Transfers
+    include Splash::Helpers
+    include Splash::Exiter
+    include Splash::Loggers
+    include Splash::Transfers
+
+
+    # Thor method : running transfer prepare
+    long_desc <<-LONGDESC
+    Prepare transfer with RSA Public key for NAME\n
+    Warning : interactive command only (prompt for passwd)
+    LONGDESC
+    desc "prepare", "Prepare transfers with RSA Public key"
+    def prepare(name)
+      acase = run_as_root :prepare_tx, name
+      splash_exit acase
+    end
+
+    # Thor method : Execute all transfers
+    long_desc <<-LONGDESC
+    Execute all transfers\n
+    Warning : interactive command only (prompt for passwd)
+    LONGDESC
+    desc "full_execute", "Execute all transfers"
+    def full_execute
+      acase = run_as_root :run_txs
+      splash_exit acase
+    end
+
+    # Thor method : Get specific result for a transfers
+    long_desc <<-LONGDESC
+    Get specific result for a transfers\n
+    LONGDESC
+    option :date, :type => :string,  :aliases => "-d"
+    desc "get_result TRANSFER", "Get specific result for a transfers "
+    def get_result(name)
+      log = get_logger
+      log.item "Transfer : #{name}"
+      config = get_config
+      data = TxRecords::new(name).get_all_records.select {|item|
+        record =item.keys.first
+        value=item[record]
+        record == options[:date]}.first
+      if data.nil? then
+        log.ko "Result for #{name} on date #{options[:date]} not found"
+        splash_exit case: :not_found, :more => "Result inexistant"
+      else
+        record = options[:date]
+        value = data[record]
+        failed = (value[:count].nil? or value[:done].nil?)? 'undef': value[:count].to_i - value[:done].count
+        if value[:end_date].nil? then
+          log.item "Event : #{record} STATUS : #{value[:status]}"
+        else
+          log.item "Tx Begin : #{record} => end : #{value[:end_date]} STATUS : #{value[:status]}"
+        end
+        log.arrow "Tx Time : #{value[:time]}" unless value[:time].nil?
+        log.arrow "nb files : #{value[:count]}" unless value[:count].nil?
+        unless value[:wanted].nil?
+          log.arrow "Files wanted :" unless value[:wanted].empty?
+          value[:wanted].each do |file|
+            log.flat  "    * #{file}"
+          end
+        end
+        unless value[:done].nil?
+          log.arrow "Files done :" unless value[:done].empty?
+          value[:done].each do |file|
+            log.flat  "    * #{file}"
+          end
+        end
+        unless failed then
+          log.arrow "Nb failure : #{failed}"
+        end
+
+      end
+      splash_exit case: :quiet_exit
+    end
+
+    # Thor method : show specfic transfers history
+    long_desc <<-LONGDESC
+    show transfers history for transfer NAME\n
+    LONGDESC
+    option :table, :type => :boolean,  :aliases => "-t"
+    desc "history", "Show transfers history"
+    def history(name)
+      log = get_logger
+      log.item "Transfer : #{name}"
+      config = get_config
+      if options[:table] then
+        table = TTY::Table.new do |t|
+          t << ["Start Date", "End date", "time", "Files count","File count error","Status"]
+          t << ['','','','','','']
+          TxRecords::new(name).get_all_records.each do |item|
+            record =item.keys.first
+            value=item[record]
+            start_date = record
+            end_date = (value[:end_date].nil?)? '': value[:end_date]
+            time  = (value[:time].nil?)? '': value[:time]
+            count = (value[:count].nil?)? '': value[:count]
+            failed = (value[:count].nil? or value[:done].nil?)? '': value[:count].to_i - value[:done].count
+            status = value[:status]
+            t << [start_date, end_date, time, count, failed, status]
+
+          end
+        end
+        if check_unicode_term  then
+          puts table.render(:unicode)
+        else
+          puts table.render(:ascii)
+        end
+
+      else
+        TxRecords::new(name).get_all_records.each do |item|
+          record =item.keys.first
+          value=item[record]
+          failed = (value[:count].nil? or value[:done].nil?)? 'undef': value[:count].to_i - value[:done].count
+          if value[:end_date].nil? then
+            log.item "Event : #{record} STATUS : #{value[:status]}"
+          else
+            log.item "Tx Begin : #{record} => end : #{value[:end_date]} STATUS : #{value[:status]}"
+          end
+          log.arrow "Tx Time : #{value[:time]}" unless value[:time].nil?
+          log.arrow "nb files : #{value[:count]}" unless value[:count].nil?
+          unless value[:wanted].nil?
+            log.arrow "Files wanted :" unless value[:wanted].empty?
+            value[:wanted].each do |file|
+              log.flat  "    * #{file}"
+            end
+          end
+          unless value[:done].nil?
+            log.arrow "Files done :" unless value[:done].empty?
+            value[:done].each do |file|
+              log.flat  "    * #{file}"
+            end
+          end
+          unless failed then
+            log.arrow "Nb failure : #{failed}"
+          end
+
+        end
+      end
+      splash_exit case: :quiet_exit
+    end
+
+
+    # Thor method : display a specific Splash configured transfer
+    desc "show TRANSFER", "show Splash configured transfer TRANSFER"
+    def show(transfer)
+      log = get_logger
+      transfer_record_set = get_config.transfers.select{|item| item[:name] == transfer.to_sym }
+      unless transfer_record_set.empty? then
+        record = transfer_record_set.first
+        log.info "Splash transfer : #{record[:name]}"
+        log.item "Description : /#{record[:desc]}/"
+        log.item "Type : #{record[:type].to_s}"
+        log.item "Backup file after copy : #{record[:backup].to_s}"
+        log.item "Local spool"
+        log.arrow "Path : #{record[:local][:path]}"
+        log.arrow "User : #{record[:local][:user]}"
+        log.item "Remote spool"
+        log.arrow "Path : #{record[:remote][:path]}"
+        log.arrow "User : #{record[:remote][:user]}"
+        log.arrow "Host : #{record[:remote][:host]}"
+        log.item "Post execution"
+        log.arrow "Remote command : #{record[:post][:remote_command]}" unless record[:post][:remote_command].nil?
+        log.arrow "Local command : #{record[:post][:local_command]}" unless record[:post][:local_command].nil?
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_found, :more => "log not configured"
+      end
+    end
+
+    # Thor method : display the full list of Splash configured transfers
+    desc "list", "List all Splash configured transfers"
+    long_desc <<-LONGDESC
+    Show configured transfers\n
+    with --detail, show transfers details
+    LONGDESC
+    option :detail, :type => :boolean,  :aliases => "-D"
+    def list
+      log = get_logger
+      log.info "Splash configured transfer :"
+      tx_record_set = get_config.transfers
+      log.ko 'No configured transfers found' if tx_record_set.empty?
+      tx_record_set.each do |record|
+        log.item "Transfer : #{record[:name]} Description : #{record[:desc]}"
+        if options[:detail] then
+          log.arrow "Type : #{record[:type].to_s}"
+          log.arrow "Backup file after copy : #{record[:backup].to_s}"
+          log.arrow "Local spool"
+          log.flat "   * Path : #{record[:local][:path]}"
+          log.flat "   * User : #{record[:local][:user]}"
+          log.arrow "Remote spool"
+          log.flat "   * Path : #{record[:remote][:path]}"
+          log.flat "   * User : #{record[:remote][:user]}"
+          log.flat "   * Host : #{record[:remote][:host]}"
+          log.arrow "Post execution"
+          log.flat "   * Remote command : #{record[:post][:remote_command]}" unless record[:post][:remote_command].nil?
+          log.flat "   * Local command : #{record[:post][:local_command]}" unless record[:post][:local_command].nil?
+        end
+      end
+      splash_exit case: :quiet_exit
+    end
+
+  end
+
+end

data/lib/splash/cli/webadmin.rb

@@ -14,14 +14,14 @@ module CLISplash
     # Thor method : stopping Splash Webadmin
     desc "stop", "Stopping Splash Webadmin Daemon"
     def stop
-      acase = run_as_root :stopdaemon, options
+      acase = run_as_root :stopweb, options
       splash_exit acase
     end
 
     # Thor method : getting execution status of Splashd
     desc "status", "Splash WebAdmin Daemon status"
     def status
-      acase = run_as_root :statusdaemon, options
+      acase = run_as_root :statusweb, options
       splash_exit acase
     end
 
@@ -37,7 +37,7 @@ module CLISplash
     LONGDESC
     desc "start", "Splash WebAdmin Daemon status"
     def start
-      acase = run_as_root :startdaemon
+      acase = run_as_root :startweb
       splash_exit acase
     end