prometheus-splash 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6036da9aa1ce8abf1bc28d87c034152654cd75518d46b95bd683f9642b01186c
-  data.tar.gz: ac742574fd569bed467ac95fc33029339335beef8e596717444f6fe74c3bc446
+  metadata.gz: 7d75be43cdbdc1c7e5cd951946d8ff25bf0da4225c65d2f1150b986179a2be6a
+  data.tar.gz: 6f10a62124372883c15723a1e28d9e439d105cf70b7e30162e7dd16cfd09e0a7
 SHA512:
-  metadata.gz: af38c990376f81466c893c140946b22ad492cdda47cd0c9fb874ce90dcf543151cee2d8a7f8b285b537d1dd909551839efce6e988256fa5131fe52feac6e77db
-  data.tar.gz: 07742cabe62fa85017c35a1d29e1804060f43113313a071777db977b423ea7668f9bdbe5cd1b78b7af68fd9cd8401540f80a010e5f25803858bca18ef5c5992a
+  metadata.gz: b55b81edb62e943d53393a9b2dbafecb94e82ff7aacd9feb35480b8184c82585d2267ae97e5d67f6797f2a9df8b67424f04912721d97dea3512a7edb597fad99
+  data.tar.gz: '059dc2af31e92868090913afe9ae8044b4d995e4df6ea6a0ca9492ba4a341aada92a684d79857c04a77ad7b675106fc9a21719933d7e4ef2b352c6505e7771a9'

data/.github/workflows/ruby.yml

@@ -0,0 +1,25 @@
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake spec
+        bundle exec rake build

data/CHANGELOG

@@ -0,0 +1,26 @@
+# SPLASH CHANGELOG
+
+
+## V 0.3.0 2020/04/11
+
+* Begining of Changelog tracking
+
+## V 0.4.0 2020/04/14
+
+### DOC :
+
+* adding \n for LONGDESC Thor #14
+* Doc for command name format in YAML #2
+
+### CHANGE :
+
+* RabbitMQ Credentials and vhosts support #16
+* backend hardening #18
+* remote show with --hostname #12
+
+
+### FEATURE :
+
+* CLI colors and logger CLI /dual #8
+* Log for splash daemon #6
+* Schedule command via daemon execute and --hostname #11

data/README.md

@@ -4,9 +4,22 @@
 
 SPLASH is **Supervision with Prometheus of Logs and Asynchronous tasks orchestration for Services or Hosts**
 
+* Author : Romain GEORGES
+* COPYright : BSD-2-Clause (c) 2020 Ultragreen Software
+* Web : http://www.ultragreen.net
+* Github : https://github.com/Ultragreen/prometheus-splash
+* Rubygems : https://rubygems.org/gems/prometheus-splash
+* DOC yardoc : https://www.rubydoc.info/gems/prometheus-splash/0.3.0
 
 Prometheus Logs and Batchs supervision over PushGateway
 
+[![GitHub version](https://badge.fury.io/gh/Ultragreen%2Fprometheus-splash.svg)](https://badge.fury.io/gh/Ultragreen%2Fprometheus-splash)
+![Ruby](https://github.com/Ultragreen/prometheus-splash/workflows/Ruby/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/prometheus-splash.svg)](https://badge.fury.io/rb/prometheus-splash)
+
+## Design
+
+![Splash Design](assets/images/splash_design.png)
 
 ## Preconfiguration
 
@@ -289,6 +302,13 @@ To see all the commands in the 'commands' submenu :
 
 Commands or Commands Sequences must be defined in the main configuration file '/etc/splash.yml'
 
+Command name must be Ruby Symbols, so in the YAML file, it must look like :
+
+    :xxxxxx:
+
+_with x in the following list [A-Za-z_0-9]_
+
+
 *Exemple* in default configuration :
 
     ### configuration of commands and scheduling
@@ -350,10 +370,21 @@ may include :
 * :user: the userneme to use to run the command
 * :on_failure: the name of an other defined command, to, execute if exit_code > 0
 * :on_success: the name of an other defined command, to, execute if exit_code = 0
-* :schedule:  (hash) a scheduling for daemon, after in this documentation, it support :
+* :schedule:  (Hash) a scheduling for daemon, after in this documentation, it support :
   * :every: "<timing>" ex: "1s", "3m", "2h"
   * :at: "<date/time>" ex: "2030/12/12 23:30:00"
   * :cron: * * * * * a cron format
+* delegate_to: (Hash) a Slash delagation
+  * :host: the hostname of an other Confiugured Splash Node.
+  * :remote_command: a command defined in the remote Splash node Configuration
+
+_Remarque_ : Command name, as precise earlier in this documentation is Ruby Symbols ':xxxxx'.
+In YAML as a Hash key : ':xxxxxx: ', but as a value _':xxxxx'_, so the synthaxe for callbacks :
+
+    :on_success: :xxxxxx
+    :on_failure: :xxxxxx
+
+It's the same for :remote_command
 
 [Rufus Scheduler Doc](https://github.com/jmettraux/rufus-scheduler)
 
@@ -704,3 +735,8 @@ EXIT_MAP= {
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+
+## Context
+
+*Massively made during COVID-19 containment : #StayAtHomeSoftware*

data/bin/splash

@@ -10,7 +10,15 @@ $-w = nil
 include Splash::Dependencies
 include Splash::Helpers
 include Splash::Exiter
+include Splash::Loggers
+include Splash::Config
 
+unless verify_file(name: CONFIG_FILE, mode: "644", owner: user_root, group: group_root).empty? then
+  puts 'ERROR: Splash need reconfiguration : execution abort, '
+  puts ' => Restart after rebuild (recheck for homemade templates) :'
 
+  acase = run_as_root :setupsplash
+  splash_exit acase
+end
 
- CLI.start(ARGV)
+CLI.start(ARGV)

data/config/splash.yml

@@ -2,6 +2,13 @@
 :splash:
 
 ### Main Configuration
+  :loggers:
+    :level: :info
+    :daemon:
+      :file: /var/log/splash.log
+    :cli:
+      :emoji: true
+      :color: true
   :templates:
     :execution:
       :path: /etc/splash_execution_report.tpl
@@ -9,7 +16,7 @@
     :stores:
       :execution_trace:
           :type: :file
-          :path: /tmp/splash
+          :path: /var/run/splash
 #      :execution_trace:
 #        :type: :redis
 #        :host: localhost
@@ -19,15 +26,17 @@
   :transports:
     :active: :rabbitmq
     :rabbitmq:
-      :url: amqp://127.0.0.1
+      :vhost: /
       :port: 5672
       :host: "localhost"
+      # :passwd: testpasswd
+      # :user: test
   :daemon:
     :logmon_scheduling:
       :every: 20s
     :process_name: "Splash : daemon."
     :paths:
-      :pid_path: /tmp
+      :pid_path: /var/run
       :trace_path: /tmp/splash
     :files:
       :stdout_trace: stdout.txt
@@ -88,6 +97,7 @@
       :delegate_to:
         :host: omicron
         :remote_command: :echo2
+      :on_success: :echo3
 
 
 ### configuration of monitored logs

data/lib/splash/backends/file.rb

@@ -3,9 +3,14 @@ module Splash
   module Backends
     class File
       include Splash::Config
+      include Splash::Exiter
+      include Splash::Helpers
+      include Splash::Loggers
+
       def initialize(store)
         @config = get_config[:backends][:stores][store]
         @path = @config[:path]
+        ensure_backend
       end
 
       def list(pattern='*')
@@ -36,6 +41,17 @@ module Splash
         return "#{astring}.trace"
       end
 
+      def ensure_backend
+        unless verify_folder(name: @config[:path], mode: "644", owner: get_config.user_root, group: get_config.group_root).empty? then
+          get_logger.warn "File Backend folder : #{@config[:path]} is missing"
+          if make_folder path: @config[:path], mode: "644", owner: get_config.user_root, group: get_config.group_root then
+            get_logger.ok "File Backend folder : #{@config[:path]} created"
+          else
+            splash_exit case: :configuration_error, more: "File backend creation error"
+          end
+        end
+      end
+
     end
   end
 

data/lib/splash/cli/commands.rb

@@ -8,6 +8,7 @@ module CLISplash
     include Splash::Exiter
     include Splash::Transports
     include Splash::Templates
+    include Splash::Loggers
 
     desc "execute NAME", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
@@ -16,7 +17,7 @@ module CLISplash
     with --ack, notify errorcode=0 to Prometheus PushGateway\n
     with --no-notify, bypass Prometheus notification\n
     with --no-callback, never execute callback (:on_failure, :on_success)\n
-                        never follow sequences
+                        never follow sequences\n
     with --hostname, execute on an other Splash daemon node
     LONGDESC
     option :trace, :type => :boolean, :default => true
@@ -25,11 +26,12 @@ module CLISplash
     option :callback, :type => :boolean, :default => true
     option :hostname, :type => :string
     def execute(name)
+      log = get_logger
       if is_root? then
         if options[:hostname] then
           splash_exit({ :case => :options_incompatibility, :more => '--hostname forbidden with delagate commands'}) if get_config.commands[name.to_sym][:delegate_to]
-          puts "Remote Splash configured commands on #{options[:hostname]}:"
-          puts "ctrl+c for interrupt"
+          log.info "Remote Splash configured commands on #{options[:hostname]}:"
+          log.info "ctrl+c for interrupt"
           begin
             transport = get_default_client
             if transport.class == Hash  and transport.include? :case then
@@ -68,18 +70,61 @@ module CLISplash
     end
 
 
+    desc "schedule NAME", "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
+    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
+    NOTES : Scheduling, force trace, notifying and callback.
+    LONGDESC
+    option :hostname, :type => :string
+    option :at, :type => :string
+    option :in, :type => :string
+    def schedule(name)
+      log = get_logger
+      hostname = (options[:hostname])? options[:hostname] : Socket.gethostname
+      splash_exit({ :case => :options_incompatibility, :more => '--at or --in is required'}) unless options[:at] or options[:in]
+      splash_exit({ :case => :options_incompatibility, :more => '--at an --in'}) if options[:at] and options[:in]
+      log.info "Remote Splash scheduling command on #{hostname}:"
+      log.info "ctrl+c for interrupt"
+      begin
+        transport = get_default_client
+        if transport.class == Hash  and transport.include? :case then
+          splash_exit transport
+        else
+          schedule = { :in => options[:in]} if options[:in]
+          schedule = { :at => options[:at]} if options[:at]
+          res = transport.execute({ :verb => :execute_command,
+                                  payload: {:name => name, :schedule => schedule},
+                                  :return_to => "splash.#{Socket.gethostname}.returncli",
+                                  :queue => "splash.#{hostname}.input" })
+          log.receive "Execute command sheduled confirmed"
+          res[:more] = "Remote command : :execute_command with schedule"
+          splash_exit res
+        end
+      rescue Interrupt
+        splash_exit case: :interrupt, more: "Remote command exection"
+      end
+
+    end
+
+
     desc "treeview", "Show commands sequence tree"
     def treeview(command, depht = 0)
-      puts "Command : #{command.to_s}" if depht == 0
+      log  = get_logger
+      log.info "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]}"
+        spacer=  " " * depht + " "
+        log.flat "#{spacer}* 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]}"
+        spacer = " " * depht + " "
+        log.flat "#{spacer}* on success => #{cmd[:on_success]}"
         treeview(cmd[:on_success],depht+2)
       end
       splash_exit case: :quiet_exit
@@ -88,17 +133,18 @@ module CLISplash
 
     desc "list", "Show configured commands"
     long_desc <<-LONGDESC
-    Show configured commands
-    with --detail, show command details
-    with --hostname, ask other splash daemon via transport
+    Show configured commands\n
+    with --detail, show command details\n
+    with --hostname, ask other Splash daemon via transport\n
     LONGDESC
     option :detail, :type => :boolean
     option :hostname, :type => :string
     def list
+      log = get_logger
       list = {}
       if options[:hostname] then
-        puts "Remote Splash configured commands on #{options[:hostname]}:"
-        puts "ctrl+c for interrupt"
+        log.info "Remote Splash configured commands on #{options[:hostname]}:"
+        log.info  "ctrl+c for interrupt"
         begin
           transport = get_default_client
           if transport.class == Hash  and transport.include? :case then
@@ -112,20 +158,20 @@ module CLISplash
           splash_exit case: :interrupt, more: "remote list Command"
         end
       else
-        puts "Splash configured commands :"
+        log.info "Splash configured commands :"
         list = get_config.commands
       end
-      puts 'No configured commands found' if list.keys.empty?
+      log.ko 'No configured commands found' if list.keys.empty?
       list.keys.each do |command|
-        puts " * #{command.to_s}"
+        log.item "#{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]
+          log.arrow "command line : '#{list[command][:command]}'"
+          log.arrow "command description : '#{list[command][:desc]}'"
+          log.arrow "command failure callback : '#{list[command.to_sym][:on_failure]}'" if list[command.to_sym][:on_failure]
+          log.arrow "command success callback : '#{list[command.to_sym][:on_success]}'" if list[command.to_sym][:on_success]
           if list[command.to_sym][:schedule]
             sched,val = list[command.to_sym][:schedule].flatten
-            puts "   - command scheduled : #{sched} #{val}."
+            log.arrow "command scheduled : #{sched} #{val}."
           end
         end
       end
@@ -134,14 +180,42 @@ module CLISplash
 
 
     desc "show COMMAND", "Show specific configured command COMMAND"
+    long_desc <<-LONGDESC
+    Show specific configured command COMMAND\n
+    with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
+    LONGDESC
+    option :hostname, :type => :string
     def show(command)
-      list = get_config.commands
+      log = get_logger
+      list = {}
+      if options[:hostname] then
+        log.info "Remote Splash configured commands on #{options[:hostname]}:"
+        log.info "ctrl+c for interrupt"
+        begin
+          transport = get_default_client
+          if transport.class == Hash  and transport.include? :case then
+            splash_exit transport
+          else
+            list = transport.execute({ :verb => :list_commands,
+                                  :return_to => "splash.#{Socket.gethostname}.returncli",
+                                  :queue => "splash.#{options[:hostname]}.input" })
+          end
+        rescue Interrupt
+          splash_exit case: :interrupt, more: "remote list Command"
+        end
+      else
+        list = get_config.commands
+      end
       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]
+        log.info "Splash command : #{command}"
+        log.item "command line : '#{list[command.to_sym][:command]}'"
+        log.item "command description : '#{list[command.to_sym][:desc]}'"
+        log.item "command failure callback : '#{list[command.to_sym][:on_failure]}'" if list[command.to_sym][:on_failure]
+        log.item "command success callback : '#{list[command.to_sym][:on_success]}'" if list[command.to_sym][:on_success]
+        if list[command.to_sym][:schedule]
+          sched,val = list[command.to_sym][:schedule].flatten
+          log.item "command scheduled : #{sched} #{val}."
+        end
         splash_exit case: :quiet_exit
       else
         splash_exit case: :not_found, :more => 'Command not configured'
@@ -151,11 +225,12 @@ 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
+    Show last running result for specific configured command COMMAND\n
     with --hostname <HOSTNAME>, an other Splash monitored server (only with Redis backend configured)
     LONGDESC
     option :hostname, :type => :string
     def lastrun(command)
+      log = get_logger
       backend = get_backend :execution_trace
       redis = (backend.class == Splash::Backends::Redis)? true : false
       if not redis and options[:hostname] then
@@ -166,7 +241,7 @@ module CLISplash
         list = backend.list("*", options[:hostname]).map(&:to_sym)
       end
       if list.include? command.to_sym then
-        print "Splash command #{command} previous execution report:\n\n"
+        log.info "Splash command #{command} previous execution report:\n"
         req  = { :key => command}
         req[:hostname] = options[:hostname] if options[:hostname]
         if backend.exist? req then
@@ -175,9 +250,9 @@ module CLISplash
               list_token: get_config.execution_template_tokens,
               template_file: get_config.execution_template_path)
           tp.map YAML::load(res)
-          print tp.output
+          log.flat tp.output
         else
-          puts "Command not already runned."
+          log.ko "Command not already runned."
         end
         splash_exit case: :quiet_exit
       else
@@ -187,11 +262,11 @@ module CLISplash
 
     desc "getreportlist", "list all executions report results "
     long_desc <<-LONGDESC
-    list all executions report results
+    list all executions report results\n
     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
-    with --detail, get major informations of each reports
+    with --detail, get major informations of each reports\n
     --all and --hostname are exclusives
     LONGDESC
     option :pattern, :type => :string
@@ -199,6 +274,7 @@ module CLISplash
     option :all, :type => :boolean, :negate => false
     option :detail, :type => :boolean
     def getreportlist
+      log = get_logger
       if options[:hostname] and options[:all] then
         splash_exit case: :options_incompatibility, more: "--all, --hostname"
       end
@@ -215,26 +291,26 @@ module CLISplash
       else
         res = backend.list pattern
       end
-      print "List of Executions reports :\n\n"
-      puts "Not reports found" if res.empty?
+      log.info "List of Executions reports :\n"
+      log.ko "Not reports found" if res.empty?
       res.each do |item|
         host = ""
         command = ""
         if options[:all]
           host,command = item.split('#')
-          puts " * Command : #{command} @ host : #{host}"
+          log.item "Command : #{command} @ host : #{host}"
         else
           command = item
-          puts " * Command : #{command}"
+          log.item "Command : #{command}"
         end
         if options[:detail] then
           req = { :key => command }
           req[:hostname] = host if options[:all]
           res = YAML::load(backend.get(req))
-          puts "   - Status : #{res[:status]}"
-          puts "   - Start date : #{res[:start_date]}"
-          puts "   - End date : #{res[:end_date]}"
-          puts "   - Execution time : #{res[:exec_time]}"
+          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]}"
         end
       end
       splash_exit case: :quiet_exit