prometheus-splash 0.4.5 → 0.6.1

data/lib/splash/cli/daemon.rb

@@ -1,14 +1,18 @@
 # coding: utf-8
+
+# module for all Thor subcommands
 module CLISplash
 
+  # Thor inherited class for splashd daemon management
   class CLIController < Thor
-    include Splash::LogsMonitor::DaemonController
+    include Splash::Daemon::Controller
     include Splash::Transports
     include Splash::Exiter
     include Splash::Loggers
 
 
-    option :foreground, :type => :boolean
+    # Thor method : starting Splashd
+    option :foreground, :type => :boolean,  :aliases => "-F"
     option :purge, :type => :boolean, default: true
     option :scheduling, :type => :boolean, default: true
     long_desc <<-LONGDESC
@@ -19,25 +23,15 @@ module CLISplash
     LONGDESC
     desc "start", "Starting Splash Daemon"
     def start
-      log = get_logger
-      if options[:purge] then
-        transport = get_default_client
-        if transport.class == Hash  and transport.include? :case then
-          splash_exit transport
-        else
-          queue = "splash.#{Socket.gethostname}.input"
-          transport.purge queue: queue
-          log.info "Queue : #{queue} purged"
-        end
-      end
       acase = run_as_root :startdaemon, options
       splash_exit acase
     end
 
-
+    # Thor method : purge transport input queue of Splashd daemon
     desc "purge", "Purge Transport Input queue of Daemon"
     def purge
       log = get_logger
+      log.level = :fatal if options[:quiet]
       transport = get_default_client
       if transport.class == Hash  and transport.include? :case then
         splash_exit transport
@@ -49,18 +43,21 @@ module CLISplash
       end
     end
 
+    # Thor method : stopping Splashd
     desc "stop", "Stopping Splash Daemon"
     def stop
       acase = run_as_root :stopdaemon
       splash_exit acase
     end
 
+    # Thor method : getting execution status of Splashd
     desc "status", "Splash Daemon status"
     def status
       acase = run_as_root :statusdaemon
       splash_exit acase
     end
 
+    # Thor method : sending ping verb over transport in the input queue of Splashd
     desc "ping HOSTNAME", "send a ping to HOSTNAME daemon over transport (need an active tranport), Typicallly RabbitMQ"
     def ping(hostname=Socket.gethostname)
       log = get_logger

data/lib/splash/cli/documentation.rb

@@ -1,11 +1,14 @@
 # coding: utf-8
+
+# module for all Thor subcommands
 module CLISplash
 
+  # Thor inherited class for documentation management
   class Documentation < Thor
     include Splash::Config
     include Splash::Exiter
 
-
+    # Thor method : display the readme file Typicallly formatted in Markdown
     desc "readme", "Display README file"
     option :formatted, :type => :boolean, :default => true
     def readme
@@ -14,7 +17,7 @@ module CLISplash
       if options[:formatted] then
         content = TTY::Markdown.parse_file(filename)
       else
-        conten = File::readlines(filename).join
+        content = File::readlines(filename).join
       end
       pager = TTY::Pager.new
       pager.page(content)

data/lib/splash/cli/logs.rb

@@ -1,35 +1,39 @@
 # coding: utf-8
+
+# module for all Thor subcommands
 module CLISplash
 
+  # Thor inherited class for documentation management
   class Logs < Thor
     include Splash::Config
     include Splash::Exiter
+    include Splash::Logs
 
-
-    desc "analyse", "analyze logs in config"
+    # Thor method : running Splash configured logs monitors analyse
+    desc "analyse", "analyze logs defined in Splash config"
     def analyse
       log  = get_logger
-      results = Splash::LogScanner::new
+      results = LogScanner::new
       res = results.analyse
-      log.info "SPlash Configured logs status :"
+      log.info "SPlash Configured log monitors :"
       full_status = true
       results.output.each do |result|
         if result[:status] == :clean then
-          log.ok "Log : #{result[:log]} : no errors"
+          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]} : missing !"
+          log.ko "Log : #{result[:log]} with label : #{result[:label]} : missing !"
           log.item "Detected pattern : #{result[:pattern]}"
         else
-          log.ko "Log : #{result[:log]} : #{result[:count]} errors"
+          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
-      display_status = (full_status)? "OK": "KO"
+
       if full_status then
         log.ok "Global status : no error found"
       else
@@ -38,44 +42,50 @@ module CLISplash
       splash_exit case: :quiet_exit
     end
 
-    desc "monitor", "monitor logs in config"
+
+    # Thor method : running Splash configured logs monitors analyse and sending to Prometheus Pushgateway
+    desc "monitor", "monitor logs defined in Splash config"
     def monitor
-      result = Splash::LogScanner::new
+      log = get_logger
+      log.level = :fatal if options[:quiet]
+      result = LogScanner::new
       result.analyse
-      result.notify
       splash_exit result.notify
 
     end
 
-    desc "show LOG", "show configured log monitoring for LOG"
+    # Thor method : display a specific Splash configured log monitor
+    desc "show LOG", "show Splash configured log monitoring for LOG"
     def show(logrecord)
       log = get_logger
-      log_record_set = get_config.logs.select{|item| item[:log] == logrecord }
+      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
     end
 
-    desc "list", "Show configured logs monitoring"
+    # Thor method : display the full list of Splash configured log monitors
+    desc "list", "List all Splash configured logs monitoring"
     long_desc <<-LONGDESC
     Show configured logs monitoring\n
     with --detail, show logs monitor details
     LONGDESC
-    option :detail, :type => :boolean
+    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]}"
+        log.item "log monitor : #{record[:log]} label : #{record[:label]}"
         if options[:detail] then
-          log.flat "  ->   pattern : /#{record[:pattern]}/"
+          log.arrow "pattern : /#{record[:pattern]}/"
         end
       end
       splash_exit case: :quiet_exit

data/lib/splash/cli/process.rb

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+# module for all Thor subcommands
+module CLISplash
+
+  # Thor inherited class for Processes management
+  class Processes < Thor
+    include Splash::Config
+    include Splash::Exiter
+    include Splash::Processes
+
+    # 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}/"
+          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
+
+      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
+    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
+    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}/"
+        end
+        splash_exit case: :quiet_exit
+      else
+        splash_exit case: :not_found, :more => "Process not configured"
+      end
+    end
+
+    # Thor method : display the full list of Splash configured processes monitors
+    desc "list", "List all Splash configured process records"
+    long_desc <<-LONGDESC
+    List all Splash configured processes record\n
+    with --detail, show process records details
+    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}/"
+          end
+        end
+      end
+      splash_exit case: :quiet_exit
+    end
+
+  end
+
+end

data/lib/splash/cli/sequences.rb

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+# module for all Thor subcommands
+module CLISplash
+
+  # Thor inherited class for sequences management
+  class Sequences < Thor
+    include Splash::Sequences
+    include Splash::Transports
+    include Splash::Exiter
+    include Splash::Loggers
+
+
+    # Thor method : execute sequence
+    option :continue, :type => :boolean, default: true
+    long_desc <<-LONGDESC
+    Execute a commands Sequence\n
+    With --no-continue, stop execution on failure
+    LONGDESC
+    desc "execute", "Execute a sequence"
+    def execute(sequence)
+      options[:name] = sequence
+      acase = run_as_root :run_seq, options
+      splash_exit acase
+    end
+
+
+    # Thor method : show sequence
+    long_desc <<-LONGDESC
+    Show a commands Sequence\n
+    LONGDESC
+    desc "show", "Show a sequence"
+    def show(sequence)
+      options = {}
+      log = get_logger
+      options[:name] = sequence
+      acase = run_as_root :show_seq, options
+      unless acase[:data].nil? then
+        dseq = acase[:data]
+        log.item sequence
+        unless dseq[:options].nil? then
+          log.arrow "Options : "
+          log.flat  "    * continue on failure : #{dseq[:options][:continue]}" unless dseq[:options][:continue].nil?
+        end
+        log.arrow "Definition :"
+        dseq[:definition].each do |step|
+          log.flat "    * Step name : #{step[:step]}"
+          log.flat "      => Splash Command to execute : #{step[:command]}"
+          log.flat "      => Execute remote on host : #{step[:on_host]}" unless step[:on_host].nil?
+          log.flat "      => Follow Callback : #{step[:callback]}" unless step[:callback].nil?
+          log.flat "      => Prometheus notification : #{step[:notification]}" unless step[:notification].nil?
+        end
+      end
+      splash_exit acase
+    end
+
+
+    # Thor method : getting the list of available sequences in splash config
+    desc "list", "Show configured sequences"
+    long_desc <<-LONGDESC
+    Show configured sequences\n
+    with --detail, show command details\n
+    LONGDESC
+    option :detail, :type => :boolean,  :aliases => "-D"
+    def list
+      acase = run_as_root :list_seq, options
+      log = get_logger
+      unless acase[:data].nil?
+        log.info "Splash configured sequences"
+        acase[:data].keys.each do |seq|
+          log.item seq
+          if options[:detail] then
+            dseq = acase[:data][seq]
+            unless dseq[:options].nil? then
+              log.arrow "Options : "
+              log.flat  "    * continue on failure : #{dseq[:options][:continue]}" unless dseq[:options][:continue].nil?
+            end
+            log.arrow "Definition :"
+            dseq[:definition].each do |step|
+              log.flat "    * Step name : #{step[:step]}"
+              log.flat "      => Splash Command to execute : #{step[:command]}"
+              log.flat "      => Execute remote on host : #{step[:on_host]}" unless step[:on_host].nil?
+              log.flat "      => Follow Callback : #{step[:callback]}" unless step[:callback].nil?
+              log.flat "      => Prometheus notification : #{step[:notification]}" unless step[:notification].nil?
+            end
+          end
+        end
+      end
+      splash_exit acase
+    end
+
+
+    # Thor method : scheduling execution of a commands sequences in splash daemon
+    desc "schedule", "Schedule a configured sequences execution"
+    long_desc <<-LONGDESC
+    Schedule excution of command sequence on Splash daemon\n
+    with --at TIME/DATE, Schedule at specified date/time, like 2030/12/12 23:30:00 or 12:00 \n
+    with --in TIMING, Schedule in specified timing, like 12s, 1m, 2h, 3m10s, 10d\n
+    --in and --at are imcompatibles.\n
+    WARNING : scheduling by CLI are not percisted, so use it only for specifics cases.\n
+    LONGDESC
+    option :at, :type => :string
+    option :in, :type => :string
+    def schedule(sequence)
+      options[:sequence] = sequence
+      acase = run_as_root :schedule_seq, options
+      splash_exit acase
+    end
+
+  end
+
+end

data/lib/splash/cli/webadmin.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+# module for all Thor subcommands
+module CLISplash
+
+  # Thor inherited class for Processes management
+  class WebAdmin < Thor
+    include Splash::WebAdmin::Controller
+    include Splash::Config
+    include Splash::Exiter
+    include Splash::Helpers
+
+
+    # Thor method : stopping Splash Webadmin
+    desc "stop", "Stopping Splash Webadmin Daemon"
+    def stop
+      acase = run_as_root :stopdaemon, 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
+      splash_exit acase
+    end
+
+
+
+
+
+
+
+    # Thor method : getting execution status of Splash WebAdmin
+    long_desc <<-LONGDESC
+    Starting Splash Daemon\n
+    LONGDESC
+    desc "start", "Splash WebAdmin Daemon status"
+    def start
+      acase = run_as_root :startdaemon
+      splash_exit acase
+    end
+
+  end
+
+end