prometheus-splash 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e6fae61b205672ab555b7cd28f0c0bfc0c48bacbaa81f9696a7ce16ef9eaa2e
-  data.tar.gz: e9167d60ea4537298014c7af7ee5214ff124d66b1b880925b18069e3a2e5db88
+  metadata.gz: 4f2d1cf627c0fd2371da011a6a97a24e82498b9a28b3d4d0485e185841bf7438
+  data.tar.gz: e0982026ea749cad8366f420e88cd376bcc8bd0a45e0ec292cc1b9a8237764c2
 SHA512:
-  metadata.gz: 5b7e241e27d99e1ca480d387a1c87a86583113d2393756200dc1b167b069b7c24253c911a6dfd05c352f821c3d5e4c691a74a2ace2611f6adf08c545d76019aa
-  data.tar.gz: 6c5c3579c210e000bdac1f9220b0b89d5bb6e0f1997ea48061d7fe8734546689f18b22fa5d083c4a3fb36e6333b7cdf05637f3dd4c4b5d62ed0988050d758b26
+  metadata.gz: b43dcf0493e86ac31da666c4a68c8f2f22f804231f1fd6c0bcc98e3235605e80a4c8e8def976a7c4bf1c54110bdbfe0e67d64040c9d857d23dc16a324cdd1826
+  data.tar.gz: 18b7dea993feea9e1a276bf02b5542d98a772754eb68b113bde17ba5f69ec9c346eaa56520d8b960aa658ba1cc4b53a17dd5f7e4af256f8d07b404131573acd4

data/Rakefile

@@ -27,6 +27,7 @@ CLOBBER.include('*.tmp', 'build/*','#*#')
 content = File::readlines(File.join(File.dirname(__FILE__), 'prometheus-splash.gemspec')).join
 spec = eval(content)
 
+
 RSpec::Core::RakeTask.new('spec')
 
 YARD::Rake::YardocTask.new do |t|

data/bin/splash

@@ -5,6 +5,8 @@ begin
   require 'prometheus/client'
   require 'prometheus/client/push'
   require 'thor'
+  require 'rufus-scheduler'
+
 rescue Gem::GemNotFoundException
   $stderr.puts "Loadind error, it's like you try to run Splash, with a lake of dependencies."
   $stderr.puts "If you run on RVM, please run with rvmsudo and not with sudo."
@@ -17,9 +19,11 @@ require 'splash/constants'
 require 'splash/helpers'
 require 'splash/config'
 require 'splash/templates'
+require 'splash/backends'
 
 require 'splash/commands'
 require 'splash/logs'
+require 'splash/orchestrator'
 require 'splash/controller'
 
 #inhibit warning : due to prometheus-client call to URI.encode warning
@@ -32,20 +36,23 @@ module CLISplash
 
   class Commands < Thor
     include Splash::Config
+    include Splash::Backends
 
-    desc "wrap NAME", "wrapping for command or ack result"
+    desc "run NAME", "run for command/sequence or ack result"
     long_desc <<-LONGDESC
-    wrapping for command or ack result
+    Running  command or sequence or ack result
     with --no-trace prevent storing execution trace in TRACE_PATH (see config file)
     with --ack, notify errorcode=0 to Prometheus PushGateway
+    with --no-notify, bypass Prometheus notification
     LONGDESC
     option :trace, :type => :boolean, :default => true
     option :ack, :type => :boolean, negate: false
+    option :notify, :type => :boolean, :default => true
     def wrap(name)
       if is_root? then
         command =  Splash::CommandWrapper::new(name)
         command.ack if options[:ack]
-        command.call_and_notify trace: options[:trace]
+        command.call_and_notify trace: options[:trace], notify: options[:notify]
       else
         $stderr.puts "Command wrapping need to be run as root"
         exit 60
@@ -53,6 +60,31 @@ module CLISplash
     end
 
 
+
+    desc "treeview", "Show commands sequence tree"
+    def treeview(command, depht = 0)
+      puts "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]}"
+        treeview(cmd[:on_failure], depht+2)
+      end
+      if cmd[:on_success] then
+        print " " * depht + " "
+        puts "* on success => #{cmd[:on_success]}"
+        treeview(cmd[:on_success],depht+2)
+      end
+    end
+
+
+
+
+
+
+
+
+
     desc "list", "Show configured commands"
     long_desc <<-LONGDESC
     Show configured commands
@@ -63,11 +95,13 @@ module CLISplash
       puts "Splash configured commands :"
       list = get_config.commands
       puts 'No configured commands found' if list.keys.empty?
-      listc.keys.each do |command|
+      list.keys.each do |command|
         puts " * #{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]
         end
       end
     end
@@ -80,6 +114,8 @@ module CLISplash
         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]
       else
         $stderr.puts "Command not configured"
         exit 50
@@ -92,9 +128,10 @@ module CLISplash
       list = get_config.commands
       if list.keys.include? command.to_sym then
         print "Splash command #{command} previous execution report:\n\n"
-        filename = "#{get_config[:trace_path]}/#{command}_trace.last"
-        if File::exist? filename then
-          system("cat #{filename}")
+        backend = get_backend :execution_trace
+        key = "#{command}_trace.last"
+        if backend.exist? key: key then
+          print backend.get key: key
         else
           puts "Command not already runned."
         end
@@ -163,12 +200,25 @@ module CLISplash
 
 
   class Logs < Thor
+    include Splash::Config
 
     desc "analyse", "analyze logs in config"
     def analyse
-      result = Splash::LogScanner::new
-      result.analyse
-      p result.output
+      results = Splash::LogScanner::new
+      results.analyse
+      puts "SPlash Configured logs status :"
+      full_status = true
+      results.output.each do |result|
+        status = (result[:status] == :clean)? "OK": "KO"
+        puts " * Log : #{result[:log]} : [#{status}]"
+        puts "   - Detected pattern : #{result[:pattern]}"
+        puts "   - detailled Status : #{result[:status].to_s}"
+        puts "     count = #{result[:count]}" if result[:status] == :matched
+        puts "     nb lines = #{result[:lines]}" if result[:status] != :missing
+        full_status = false unless result[:status] == :clean
+      end
+      display_status = (full_status)? "OK": "KO"
+      puts "Global Status : [#{display_status}]"
     end
 
     desc "monitor", "monitor logs in config"
@@ -178,6 +228,36 @@ module CLISplash
       result.notify
     end
 
+    desc "show LOG", "show configured log monitoring for LOG"
+    def show(log)
+      log_record_set = get_config.logs.select{|item| item[:log] == log }
+      unless log_record_set.empty? then
+        record = log_record_set.first
+        puts "Splash log monitor : #{record[:log]}"
+        puts "  ->   pattern : /#{record[:pattern]}/"
+    else
+        $stderr.puts "log not configured"
+        exit 50
+      end
+    end
+
+    desc "list", "Show configured logs monitoring"
+    long_desc <<-LONGDESC
+    Show configured logs monitoring
+    with --detail, show logs monitor details
+    LONGDESC
+    option :detail, :type => :boolean
+    def list
+      puts "Splash configured log monitoring :"
+      log_record_set = get_config.logs
+      puts 'No configured commands found' if log_record_set.empty?
+      log_record_set.each do |record|
+        puts " *  log monitor : #{record[:log]}"
+        if options[:detail] then
+          puts "  ->   pattern : /#{record[:pattern]}/"
+        end
+      end
+    end
 
   end
 end

data/config/splash.yml

@@ -1,4 +1,7 @@
+# Splash Configuration
 :splash:
+
+### Main Configuration
   :templates:
     :execution:
       :path: /etc/splash_execution_report.tpl
@@ -10,31 +13,86 @@
         - :stderr
         - :desc
         - :status
-  :logs:
-    - :log: /tmp/test
-      :pattern: ERROR
-    - :log: /var/log/message
-      :pattern: error
+        - :exec_time
+  :backends:
+    :list:
+      - :file
+      - :redis
+    :stores:
+      :execution_trace:
+          :type: :file
+          :path: /tmp/splash
+#      :execution_trace:
+#        :type: :redis
+#        :host: localhost
+#        :port: 6379
+#        #:auth: "mykey"
+#        :base: 1
+  :transports:
+    :active: :rabbitmq
+    :rabbitmq:
+      :url: amqp://127.0.0.1
+  :daemon:
+    :logmon_scheduling:
+      :every: 20s
+    :process_name: "Splash : daemon."
+    :paths:
+      :pid_path: /tmp
+      :trace_path: /tmp/splash
+    :files:
+      :stdout_trace: stdout.txt
+      :stderr_trace: stderr.txt
+      :pid_file: splash.pid
   :prometheus:
     :pushgateway:
       :host: "localhost"
       :port: 9091
+
+
+### configuration of commands and scheduling
   :commands:
+    :id_root:
+      :desc: run id command on root
+      :command: id root
+    :true_test:
+      :desc: "test command returning true : 0"
+      :command: "true"
+      :schedule:
+        :every: "1h"
+      :on_failure: :ls_slash_tmp
+      :on_success: :pwd
     :false_test:
-      :desc: "test command"
+      :desc: "test command returning false > 0"
       :command: "false"
+      :schedule:
+        :every: "1h"
+      :on_failure: :ls_slash_tmp
+      :on_success: :pwd
     :ls_slash_tmp:
       :desc: list file in /tmp
       :command: ls -al /tmp
       :user: daemon
-  :daemon:
-    :user: daemon
-    :group: daemon
-    :process_name: "Splash : Prometheus logs monitoring."
-    :paths:
-      :pid_path: /tmp
-      :trace_path: /tmp/splash
-    :files:
-      :stdout_trace: stdout.txt
-      :stderr_trace: stderr.txt
-      :pid_file: splash.pid
+      :on_success: :echo1
+    :pwd:
+      :desc: run pwd
+      :command: pwd
+      :on_success: :echo1
+      :on_failure: :echo2
+    :echo1:
+      :desc: echo 'foo'
+      :command: echo foo
+      :on_failure: :echo3
+    :echo2:
+      :desc: echo 'bar'
+      :command: echo bar
+    :echo3:
+      :desc: echo 'been'
+      :command: echo been
+
+
+### configuration of monitored logs
+  :logs:
+    - :log: /tmp/test
+      :pattern: ERROR
+    - :log: /var/log/message
+      :pattern: error

data/lib/splash/backends.rb

@@ -0,0 +1,12 @@
+Dir[File.dirname(__FILE__) + '/backends/*.rb'].each {|file| require file  }
+
+module Splash
+  module Backends
+    include Splash::Config
+    def get_backend(store)
+      aclass = "Splash::Backends::#{get_config[:backends][:stores][store][:type].to_s.capitalize}"
+      return Kernel.const_get(aclass)::new(store)
+    end
+
+  end
+end

data/lib/splash/backends/file.rb

@@ -0,0 +1,35 @@
+module Splash
+  module Backends
+    class File
+      include Splash::Config
+      def initialize(store)
+        @config = get_config[:backends][:stores][store]
+        @path = @config[:path]
+      end
+
+      def list(pattern='*')
+         return Dir.glob(pattern)
+      end
+
+      def get(options)
+        return ::File.readlines("#{@path}/#{options[:key]}").join
+      end
+
+      def put(options)
+        ::File.open("#{@path}/#{options[:key]}", 'w') { |file|
+          file.write options[:value]
+        }
+      end
+
+      def del(options)
+        ::File.unlink("#{@path}/#{options[:key]}") if File.exist?("#{@path}/#{options[:key]}")
+      end
+
+      def exist?(options)
+        return ::File.exist?("#{@path}/#{options[:key]}")
+      end
+
+    end
+  end
+
+end

data/lib/splash/backends/redis.rb

@@ -0,0 +1,42 @@
+require "redis"
+
+module Splash
+  module Backends
+    class Redis
+      include Splash::Config
+      def initialize(store)
+        @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
+      end
+
+      def get(options)
+        return @store.get(options[:key])
+      end
+
+      def put(options)
+        @store.set options[:key], options[:value]
+      end
+
+      def del(options)
+        @store.del options[:key]
+      end
+
+      def flush
+        `#{@redis_cli_cmd} -n 3 flushdb`
+        # @@store.flushdb
+      end
+
+      def exist?(options)
+        return ( not @store.get(options[:key]).nil?)
+      end
+
+    end
+  end
+
+end

data/lib/splash/commands.rb

@@ -1,12 +1,13 @@
 require 'open3'
 require 'date'
-
+require 'socket'
 
 module Splash
   class CommandWrapper
     include Splash::Templates
     include Splash::Config
     include Splash::Helpers
+    include Splash::Backends
 
     def initialize(name)
       @config  = get_config
@@ -15,6 +16,12 @@ module Splash
         $stderr.puts "Splash : command #{@name} is not defined in configuration"
         exit 40
       end
+      @registry = Prometheus::Client.registry
+      @url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
+      @metric_exitcode = Prometheus::Client::Gauge.new(:errorcode, docstring: 'SPLASH metric batch errorcode')
+      @metric_time = Prometheus::Client::Gauge.new(:exectime, docstring: 'SPLASH metric batch execution time')
+      @registry.register(@metric_exitcode)
+      @registry.register(@metric_time)
     end
 
     def ack
@@ -23,39 +30,42 @@ module Splash
       exit 0
     end
 
-    def notify(value)
+    def notify(value,time)
       unless verify_service host: @config.prometheus_pushgateway_host ,port: @config.prometheus_pushgateway_port then
         $stderr.puts "Prometheus PushGateway Service IS NOT running"
         $stderr.puts "Exit without notification."
         exit 30
       end
-      registry = Prometheus::Client.registry
-      url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
-      metric = Prometheus::Client::Gauge.new(:errorcode, docstring: 'SPLASH metric batch errorcode')
-      registry.register(metric)
-      metric.set(value)
-      Prometheus::Client::Push.new(@name, nil, url).add(registry)
-      puts "Prometheus Gateway notified."
+      @metric_exitcode.set(value)
+      @metric_time.set(time)
+      hostname = Socket.gethostname
+      Prometheus::Client::Push.new(@name, hostname, @url).add(@registry)
+      puts " * Prometheus Gateway notified."
     end
 
 
     def call_and_notify(options)
       puts "Executing command : '#{@name}' "
+      start = Time.now
       unless options[:trace] then
-        puts "Traceless execution"
+        puts " * Traceless execution"
         if @config.commands[@name.to_sym][:user] then
+          puts " * Execute with user : #{@config.commands[@name.to_sym][:user]}."
           system("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
         else
           system("#{@config.commands[@name.to_sym][:command]} > /dev/null 2>&1")
         end
+        time = Time.now - start
         exit_code = $?.exitstatus
       else
-        puts "Tracefull execution"
+        puts " * Tracefull execution"
         if @config.commands[@name.to_sym][:user] then
+          puts " * Execute with user : #{@config.commands[@name.to_sym][:user]}."
           stdout, stderr, status = Open3.capture3("sudo -u #{@config.commands[@name.to_sym][:user]} #{@config.commands[@name.to_sym][:command]}")
         else
           stdout, stderr, status = Open3.capture3(@config.commands[@name.to_sym][:command])
         end
+        time = Time.now - start
         tp = Template::new(
             list_token: @config.execution_template_tokens,
             template_file: @config.execution_template_path)
@@ -67,12 +77,43 @@ module Splash
         tp.status = status.to_s
         tp.stdout = stdout
         tp.stderr = stderr
-        filename = "#{@config[:trace_path]}/#{@name}_trace.last"
-        File.open(filename, 'w') { |file| file.write(tp.output) }
+        tp.exec_time = time.to_s
+        backend = get_backend :execution_trace
+        key = "#{@name}_trace.last"
+        backend.put key: key, value: tp.output
         exit_code = status.exitstatus
+
       end
 
-      notify(exit_code)
+      puts "  => exitcode #{exit_code}"
+      if options[:notify] then
+        notify(exit_code,time.to_i)
+      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 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
+      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
+
+
       exit exit_code
     end
   end

data/lib/splash/config.rb

@@ -1,12 +1,14 @@
+require 'etc'
 module Splash
   module Config
     include Splash::Helpers
     include Splash::Constants
 
 
-
+    # Class to manage configuration in Splash from Splash::Constants override by Yaml CONFIG
     class Configuration < Hash
       include Splash::Constants
+
       def initialize(config_file=CONFIG_FILE)
         config_from_file = readconf config_file
         self[:version] = VERSION
@@ -15,24 +17,57 @@ module Splash
         self[:prometheus_pushgateway_host] = (config_from_file[:prometheus][:pushgateway][:host])? config_from_file[:prometheus][:pushgateway][:host] : PROMETHEUS_PUSHGATEWAY_HOST
         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_user] = (config_from_file[:daemon][:user])? config_from_file[:daemon][:user] : DAEMON_USER
-        self[:execution_template_tokens] = (config_from_file[:templates][:execution][:tokens])? config_from_file[:templates][:execution][:tokens] : TOKENS_LIST
+        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_path] = (config_from_file[:templates][:execution][:path])? config_from_file[:templates][:execution][:path] : EXECUTION_TEMPLATE
-        self[:daemon_group] = (config_from_file[:daemon][:group])? config_from_file[:daemon][:group] : DAEMON_GROUP
-        self[:pid_path] = (config_from_file[:daemon][:paths][:pid_path])? config_from_file[:daemon][:paths][:pid_path] : PID_PATH
+        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
-        self[:pid_file] = (config_from_file[:daemon][:files][:pid_file])? config_from_file[:daemon][:files][:pid_file] : PID_FILE
-        self[:stdout_trace] = (config_from_file[:daemon][:files][:stdout_trace])? config_from_file[:daemon][:files][:stdout_trace] : STDOUT_TRACE
-        self[:stderr_trace] = (config_from_file[:daemon][:files][:stderr_trace])? config_from_file[:daemon][:files][:stderr_trace] : STDERR_TRACE
+        self[:pid_file] = (config_from_file[:daemon][:files][:pid_file])? config_from_file[:daemon][:files][:pid_file] : DAEMON_PID_FILE
+        self[:stdout_trace] = (config_from_file[:daemon][:files][:stdout_trace])? config_from_file[:daemon][:files][:stdout_trace] : DAEMON_STDOUT_TRACE
+        self[:stderr_trace] = (config_from_file[:daemon][:files][:stderr_trace])? config_from_file[:daemon][:files][:stderr_trace] : DAEMON_STDERR_TRACE
+
+        self[:transports] = {} ; self[:transports].merge! TRANSPORTS_STRUCT ; self[:transports].merge! config_from_file[:transports] if config_from_file[:transports]
+        self[:backends] = {} ; self[:backends].merge! BACKENDS_STRUCT ; self[:backends].merge! config_from_file[:backends] if config_from_file[:backends]
+
         self[:logs] = (config_from_file[:logs])? config_from_file[:logs] : {}
         self[:commands] = (config_from_file[:commands])? config_from_file[:commands] : {}
 
       end
 
+      # @!group accessors on configurations Items
+
+      def Configuration.user_root
+        return Etc.getpwuid(0).name
+      end
+
+      def Configuration.group_root
+        return Etc.getgrgid(0).name
+      end
+
+      def user_root
+        return Configuration.user_root
+      end
+
+      def group_root
+        return Configuration.group_root
+      end
+
+
+      def backends
+        return self[:backends]
+      end
+
+      def transports
+        return self[:transport]
+      end
+
+      def daemon_logmon_scheduling
+        return self[:daemon_logmon_scheduling]
+      end
+
       def execution_template_path
         return self[:execution_template_path]
       end
-
       def execution_template_tokens
         return self[:execution_template_tokens]
       end
@@ -67,14 +102,6 @@ module Splash
         return self[:prometheus_pushgateway_port]
       end
 
-      def daemon_user
-        return self[:daemon_user]
-      end
-
-      def daemon_group
-        return self[:daemon_group]
-      end
-
       def full_pid_path
         return "#{self[:pid_path]}/#{self[:pid_file]}"
       end
@@ -87,6 +114,8 @@ module Splash
         return "#{self[:trace_path]}/#{self[:stderr_trace]}"
       end
 
+      # @!endgroup
+
       private
       def readconf(file = CONFIG_FILE)
         return YAML.load_file(file)[:splash]
@@ -95,18 +124,21 @@ module Splash
 
     end
 
-
+    # factory of Configuration Class instance
+    # @param [String] config_file the path of the YAML Config file
+    # @return [SPlash::Config::Configuration]
     def get_config(config_file=CONFIG_FILE)
       return Configuration::new config_file
     end
 
-
+    # Setup action method for installing Splash
+    # @return [Integer] an errorcode value
     def setupsplash
       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: "root", group: "wheel" then
+      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
@@ -115,7 +147,7 @@ module Splash
       config = get_config
       report_in_path = search_file_in_gem "prometheus-splash", "templates/report.txt"
       print "* Installing template file : #{config.execution_template_path} : "
-      if install_file source: report_in_path, target: config.execution_template_path, mode: "644", owner: "root", group: "wheel" then
+      if install_file source: report_in_path, target: config.execution_template_path, mode: "644", owner: config.user_root, group: config.group_root then
         puts "[OK]"
       else
         full_res =+ 1
@@ -123,7 +155,7 @@ module Splash
       end
 
       print "* Creating/Checking pid file path : #{config[:pid_path]} : "
-      if make_folder path: config[:pid_path], mode: "644", owner: "root", group: "wheel" then
+      if make_folder path: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root then
         puts "[OK]"
       else
         full_res =+ 1
@@ -131,7 +163,7 @@ module Splash
       end
 
       print "* Creating/Checking trace file path : #{config[:trace_path]} : "
-      if make_folder path: config[:trace_path], mode: "777", owner: config.daemon_user, group: config.daemon_group then
+      if make_folder path: config[:trace_path], mode: "644", owner: config.user_root, group: config.group_root then
         puts "[OK]"
       else
         full_res =+ 1
@@ -148,12 +180,14 @@ module Splash
 
     end
 
+    # Sanitycheck action method for testing installation of Splash
+   # @return [Integer] an errorcode value
     def checkconfig
       puts "Splash -> sanitycheck : "
       config = get_config
       full_res = 0
       print "* Config file : #{CONFIG_FILE} : "
-      res = verify_file(name: CONFIG_FILE, mode: "644", owner: "root", group: "wheel")
+      res = verify_file(name: CONFIG_FILE, mode: "644", owner: config.user_root, group: config.group_root)
       if res.empty? then
         print "[OK]\n"
       else
@@ -163,7 +197,7 @@ module Splash
       end
 
       print "* PID Path : #{config[:pid_path]} : "
-      res = verify_folder(name: config[:pid_path], mode: "644", owner: "root", group: "wheel")
+      res = verify_folder(name: config[:pid_path], mode: "644", owner: config.user_root, group: config.group_root)
       if res.empty? then
         print "[OK]\n"
       else
@@ -174,7 +208,7 @@ module Splash
       end
 
       print "* trace Path : #{config[:trace_path]} : "
-      res = verify_folder(name: config[:trace_path], mode: "777", owner: config.daemon_user, group: config.daemon_group)
+      res = verify_folder(name: config[:trace_path], mode: "777", owner: config.user_root, group: config.group_root)
       if res.empty? then
         print "[OK]\n"
       else
@@ -202,6 +236,11 @@ module Splash
 
     private
 
+    # facilities to find a file in gem path
+    # @param [String] _gem a Gem name
+    # @param [String] _file a file relative path in the gem
+    # @return [String] the path of the file, if found.
+    # @return [False] if not found
     def search_file_in_gem(_gem,_file)
       if Gem::Specification.respond_to?(:find_by_name)
         begin

data/lib/splash/constants.rb

@@ -1,22 +1,35 @@
 module Splash
   module Constants
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
+
     CONFIG_FILE = "/etc/splash.yml"
-    DAEMON_USER = "root"
-    DAEMON_GROUP = "wheel"
-    PID_PATH="/var/run"
     TRACE_PATH="/var/run/splash"
-    PID_FILE="splash.pid"
-    STDOUT_TRACE="stdout.txt"
-    STDERR_TRACE="stderr.txt"
-    DAEMON_PROCESS_NAME="Splash : Prometheus logs monitoring."
+
+    DAEMON_LOGMON_SCHEDULING={ :every => '20s'}
+    DAEMON_PROCESS_NAME="Splash : daemon."
+    DAEMON_PID_PATH="/var/run"
+    DAEMON_PID_FILE="splash.pid"
+    DAEMON_STDOUT_TRACE="stdout.txt"
+    DAEMON_STDERR_TRACE="stderr.txt"
+
     AUTHOR="Romain GEORGES"
     EMAIL = "gems@ultragreen.net"
     COPYRIGHT="Ultragreen (c) 2020"
     LICENSE="BSD-2-Clause"
+
     PROMETHEUS_PUSHGATEWAY_HOST = "localhost"
     PROMETHEUS_PUSHGATEWAY_PORT = "9091"
+
     EXECUTION_TEMPLATE="/etc/splash_execution_report.tpl"
-    TOKENS_LIST = [:date,:cmd_name,:cmd_line,:stdout,:stderr,:desc,:status]
+    EXECUTION_TEMPLATE_TOKENS_LIST = [:date,:cmd_name,:cmd_line,:stdout,:stderr,:desc,:status,:exec_time]
+
+    BACKENDS_STRUCT = { :list => [:file,:redis],
+                        :stores => { :execution_trace => { :type => :file, :path => "/var/run/splash" }}}
+    TRANSPORTS_STRUCT = { :list => [:rabbitmq],
+                        :active => :rabbitmq,
+                        :rabbitmq => { :url => 'amqp://localhost/'} }
+
+
+
   end
 end

data/lib/splash/controller.rb

@@ -5,6 +5,7 @@ module Splash
       include Splash::Constants
       include Splash::Helpers
       include Splash::Config
+      include Splash::Orchestrator
 
       def startdaemon(options = {})
         config = get_config
@@ -17,21 +18,9 @@ module Splash
         unless File::exist? config.full_pid_path then
           res = daemonize :description => config.daemon_process_name,
               :pid_file => config.full_pid_path,
-              :daemon_user => config.daemon_user,
-              :daemon_group => config.daemon_group,
               :stdout_trace => config.full_stdout_trace_path,
               :stderr_trace => config.full_stderr_trace_path do
-            result = LogScanner::new
-            while true
-              begin
-                sleep 5
-                puts "Notify"
-                result.analyse
-                result.notify
-              rescue Errno::ECONNREFUSED
-                $stderr.puts "PushGateway seems to be done, please start it."
-              end
-            end
+              Scheduler::new
           end
           if res == 0 then
             pid = `cat #{config.full_pid_path}`.to_i

data/lib/splash/helpers.rb

@@ -7,7 +7,10 @@ module Splash
   module Helpers
 
 
-
+    # facilité pour récupérer un PID depuis une regexp
+    # @param [Hash] options
+    # @option options [String] :pattern une regexp
+    # @return [String] le PID
     def get_process(options = {})
       pattern = options[:pattern]
       res = `ps aux|grep '#{pattern}'|grep -v grep`.to_s
@@ -18,7 +21,8 @@ module Splash
       end
     end
 
-
+    # facilité pour vérifier si le process actif est root
+    # @return [Bool] vrai ou faux
     def is_root?
       case (Process.uid)
       when 0
@@ -28,6 +32,9 @@ module Splash
       end
     end
 
+    # facilité pour s'assurer qu'on execute une méthode avec les droits root
+    # @param [Symbol] method a method name th wrap
+    # @return [void] le retour de la méthode wrappée
     def run_as_root(method)
       unless is_root?
         $stderr.puts "You need to be root to execute this subcommands : #{method.to_s}"
@@ -39,13 +46,18 @@ module Splash
     end
 
     # method for daemonize blocks
-    # @param [Hash] _options the list of options, keys are symbols
-    # @option  _options [String] :description the description of the process, use for $0
-    # @option  _options [String] :pid_file the pid filenam
+    # @param [Hash] options the list of options, keys are symbols
+    # @option  options [String] :description the description of the process, use for $0
+    # @option  options [String] :pid_file the pid filename
+    # @option  options [String] :daemon_user the user to change privileges
+    # @option  options [String] :daemon_group the group to change privileges
+    # @option  options [String] :stderr_trace the path of the file where to redirect STDERR
+    # @option  options [String] :stdout_trace the path of the file where to redirect STDOUT
+    # @option  options [Bool] :debug option to run foreground
     # @yield a process definion or block given
     # @example usage inline
     #    class Test
-    #      include Splash::Helpers::Application
+    #      include Splash::Helpers
     #      private :daemonize
     #      def initialize
     #        @loop = Proc::new do
@@ -62,7 +74,7 @@ module Splash
     #
     # @example usage block
     #    class Test
-    #      include Splash::Helpers::Application
+    #      include Splash::Helpers
     #      include Dorsal::Privates
     #      private :daemonize
     #      def initialize
@@ -88,15 +100,17 @@ module Splash
       fork do
         #Process.daemon
         File.open(options[:pid_file],"w"){|f| f.puts Process.pid } if options[:pid_file]
-        uid = Etc.getpwnam(options[:daemon_user]).uid
-        gid = Etc.getgrnam(options[:daemon_group]).gid
-        Process::UID.change_privilege(uid)
-      #  Process::GID.change_privilege(gid)
-        $stdout.reopen(options[:stdout_trace], "w")
-        $stderr.reopen(options[:stderr_trace], "w")
+        if options[:daemon_user] and options[:daemon_group] then
+          uid = Etc.getpwnam(options[:daemon_user]).uid
+          gid = Etc.getgrnam(options[:daemon_group]).gid
+          Process::UID.change_privilege(uid)
+          #  Process::GID.change_privilege(gid)
+        end
+        $stdout.reopen(options[:stdout_trace], "w") if options[:stdout_trace]
+        $stderr.reopen(options[:stderr_trace], "w") if options[:stderr_trace]
 
         #$0 = options[:description]
-        Process.setproctitle options[:description]
+        Process.setproctitle options[:description] if options[:description]
 
         yield
 
@@ -110,6 +124,9 @@ module Splash
     # @param [Hash] options
     # @option options [String] :source le chemin source du fichier
     # @option options [String] :target le chemin cible du fichier
+    # @option options [String] :mode les droits du fichier du type Octal "XXX"
+    # @option options [String] :owner le owner du fichier
+    # @option options [String] :group le groupe du fichier
     def install_file(options = {})
       #begin
         FileUtils::copy options[:source], options[:target] #unless File::exist? options[:target]
@@ -124,6 +141,9 @@ module Splash
     # facilité de création de répertoire
     # @param [Hash] options
     # @option options [String] :path le répertoire à créer (relatif ou absolut)
+    # @option options [String] :mode les droits du fichier du type Octal "XXX"
+    # @option options [String] :owner le owner du fichier
+    # @option options [String] :group le groupe du fichier
     def make_folder(options = {})
       begin
         FileUtils::mkdir_p options[:path] unless File::exist? options[:path]

data/lib/splash/logs.rb

@@ -1,3 +1,5 @@
+require 'socket'
+
 module Splash
   class LogScanner
     include Splash::Constants
@@ -5,10 +7,14 @@ module Splash
 
     def initialize
       @logs_target = get_config.logs
-
+      @config = get_config
       @registry = Prometheus::Client.registry
-      @metric = Prometheus::Client::Gauge.new(:logerror, docstring: 'SPLASH metric log error', labels: [:log ])
-      @registry.register(@metric)
+      @metric_count = Prometheus::Client::Gauge.new(:logerrors, docstring: 'SPLASH metric log error', labels: [:log ])
+      @metric_missing = Prometheus::Client::Gauge.new(:logmissing, docstring: 'SPLASH metric log missing', labels: [:log ])
+      @metric_lines = Prometheus::Client::Gauge.new(:loglines, docstring: 'SPLASH metric log lines numbers', labels: [:log ])
+      @registry.register(@metric_count)
+      @registry.register(@metric_missing)
+      @registry.register(@metric_lines)
     end
 
     def analyse
@@ -18,8 +24,9 @@ module Splash
         if File.exist?(record[:log]) then
           record[:count] = File.readlines(record[:log]).grep(/#{record[:pattern]}/).size
           record[:status] = :matched if record[:count] > 0
+          record[:lines] = `wc -l "#{record[:log]}"`.strip.split(/\s+/)[0].to_i unless record[:status] == :missing
         else
-          record[:status] = :mssing
+          record[:status] = :missing
         end
       end
     end
@@ -29,10 +36,24 @@ module Splash
     end
 
     def notify
+      unless verify_service host: @config.prometheus_pushgateway_host ,port: @config.prometheus_pushgateway_port then
+        $stderr.puts "Prometheus PushGateway Service IS NOT running"
+        $stderr.puts "Exit without notification."
+        exit 30
+      end
+      puts "Sending metrics to Prometheus Pushgateway"
       @logs_target.each do |item|
-        @metric.set(item[:count], labels: { log: item[:log] })
+        missing = (item[:status] == :missing)? 1 : 0
+        puts " * Sending metrics for #{item[:log]}"
+        @metric_count.set(item[:count], labels: { log: item[:log] })
+        @metric_missing.set(missing, labels: { log: item[:log] })
+        lines = (item[:lines])? item[:lines] : 0
+        @metric_lines.set(lines, labels: { log: item[:log] })
       end
-      Prometheus::Client::Push.new('Splash').add(@registry)
+      hostname = Socket.gethostname
+      url = "http://#{@config.prometheus_pushgateway_host}:#{@config.prometheus_pushgateway_port}"
+      Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
+      puts "Sending done."
     end
 
   end

data/lib/splash/orchestrator.rb

@@ -0,0 +1,49 @@
+module Splash
+  module Orchestrator
+
+    module SchedulerHooks
+      def on_pre_trigger(job, trigger_time)
+
+      end
+
+      def on_post_trigger(job, trigger_time)
+
+      end
+
+      def init_log
+
+      end
+    end
+
+
+    class Scheduler
+        include Splash::Constants
+        include Splash::Helpers
+        include Splash::Config
+        def initialize
+          @server  = Rufus::Scheduler::new
+          @server.extend SchedulerHooks
+          @server.init_log
+          @result = LogScanner::new
+          @server.every '20s' do
+            begin
+              puts "Notify"
+              @result.analyse
+              @result.notify
+              $stdout.flush
+            rescue Errno::ECONNREFUSED
+              $stderr.puts "PushGateway seems to be done, please start it."
+            end
+          end
+          @server.join
+        end
+
+        def terminate
+        end
+
+      end
+
+
+    end
+
+  end

data/lib/splash/transports.rb

@@ -0,0 +1,18 @@
+Dir[File.dirname(__FILE__) + '/transports/*.rb'].each {|file| require file  }
+
+module Splash
+  module Transports
+    include Splash::Config
+
+    def get_default_subscriber
+      aclass = "Splash::Transports::#{get_config[:transports][:active].to_s.capitalize}::Suscriber"
+      return Kernel.const_get(aclass)::new
+    end
+
+    def get_default_client
+      aclass = "Splash::Transports::#{get_config[:transports][:active].to_s.capitalize}::Client"
+      return Kernel.const_get(aclass)::new
+    end
+
+  end
+end

data/lib/splash/transports/rabbitmq.rb

@@ -0,0 +1,45 @@
+require 'bunny'
+module Splash
+  module Transports
+    module RabbitMQ
+
+      class Subscriber
+        def initialize
+
+        end
+      end
+
+
+      class Client
+        def initialize
+          @connection = Bunny.new
+          @connection.start
+          @channel = @connection.create_channel
+        end
+
+
+        def publish(options ={})
+          return @channel.default_exchange.publish(options[:message], :routing_key => options[:queue])
+        end
+
+        def ack
+          return @channel.acknowledge(delivery_info.delivery_tag, false)
+        end
+
+
+        def get(options ={})
+          queue = @channel.queue(options[:queue])
+          delivery_info, properties, payload = queue.pop
+          res = {:message => payload}
+          res[:ack] = delivery_info.delivery_tag if options[:noack]
+          return res
+        end
+
+        def close
+          @connection.close
+        end
+
+      end
+    end
+  end
+end

data/prometheus-splash.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Splash::Constants::VERSION
   spec.authors       = [Splash::Constants::AUTHOR]
   spec.email         = [Splash::Constants::EMAIL]
-  spec.description   = %q{Prometheus Logs and Batchs supervision over PushGateway}
-  spec.summary       = %q{Supervision with Prometheus of Logs and Asynchronous tasks for Services or Hosts }
+  spec.description   = %q{Prometheus Logs and Batchs supervision over PushGateway and commands orchestration}
+  spec.summary       = %q{Supervision with Prometheus of Logs and Asynchronous tasks orchestration for Services or Hosts }
   spec.homepage      = "http://www.ultragreen.net"
   spec.license       = Splash::Constants::LICENSE
   spec.require_paths << 'bin'
@@ -21,6 +21,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.add_runtime_dependency 'thor','~> 1.0.1'
   spec.add_runtime_dependency 'prometheus-client','~> 2.0.0'
+  spec.add_runtime_dependency 'rufus-scheduler','~> 3.6.0'
+  spec.add_runtime_dependency 'redis','~> 4.1.3'  
   spec.add_development_dependency 'rake', '~> 13.0.1'
   spec.add_development_dependency 'rspec', '~> 3.9.0'
   spec.add_development_dependency 'yard', '~> 0.9.24'

data/spec/templates_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../lib/splash/templates'
+
+include Splash::Templates
+
+describe Template do
+  $template_file = "/tmp/template.txt"
+  $nonexistantfile = "/tmp/nonexistant.txt"
+  $template = "Hello %%NAME%% !!"
+  $result = "Hello Romain !!"
+  $goodtoken = :name
+  $badtoken = :surname
+  $value = 'Romain'
+  before :all do
+    `echo "#{$template}" > #{$template_file}`
+    File::unlink($nonexistantfile) if File::exist?($nonexistantfile)
+  end
+  subject { Template }
+  specify { should be_an_instance_of Class }
+  context "Exception case" do
+    it "should raise NoTemplateFile if template file not exist" do
+      expect { Template::new({:list_token => [$goodtoken] , :template_file => $nonexistantfile}) }.to raise_error NoTemplateFile
+    end
+    it "should raise NotAToken if try to send ##{$badtoken} and '#{$badtoken}' not a valid token" do
+      expect { Template::new({ :list_token => [$goodtoken], :template_file => $template_file}).send($badtoken.to_sym)}.to raise_error NotAToken
+    end
+    it "should raise InvalidTokenList if initialized with ['#{$goodtoken}','#{$badtoken}'] tokens list" do
+      expect { Template::new({ :list_token => [$goodtoken,$badtoken] , :template_file => $template_file})}.to raise_error InvalidTokenList
+    end
+    it "should raise NoTemplateFile if template file not exist AND initialized with ['#{$goodtoken}','#{$badtoken}'] tokens list" do
+      expect { Template::new({ :list_token => [$goodtoken,$badtoken] , :template_file => $nonexistantfile})}.to raise_error NoTemplateFile
+    end
+  end
+
+  context "Template <execution> with token '#{$goodtoken}', content = '#{$content}', and ##{$goodtoken}='#{$value}'" do
+    before :all do
+      $test = Template::new({ :list_token => [$goodtoken] , :template_file => $template_file})
+    end
+    context "#content" do
+      specify {expect($test.content).to be_an_instance_of String }
+      it "should have '#{$template}' in #content" do
+        expect( $test.content).to eq($template)
+      end
+      specify {expect($test).to_not respond_to 'content=' }
+    end
+    context "#token_list" do
+      specify {expect($test.list_token).to be_an_instance_of Array }
+      it "should have ['#{$goodtoken}'] in #list_token" do
+        expect($test.list_token).to eq([$goodtoken])
+      end
+      specify { expect($test).to_not respond_to 'token_list=' }
+    end
+    context "virtual (methode_missing) #{$goodtoken}" do
+      specify { expect($test.send($goodtoken.to_sym)).to be_an_instance_of String }
+      specify { expect($test).to respond_to(:name) }
+      specify { $test.name = $value; expect($test.name).to eq($value) }
+      it "should raise ArgumentError if virtual methode '#name=' got non String arguement (accessor)" do
+        expect { $test.name = 1 }.to raise_error ArgumentError
+      end
+    end
+    context "#output" do
+      it "should #output 'Hello Romain !!' if set #name = 'Romain' and msg send #output" do
+        $test.name = 'Romain'
+        expect( $test.output).to eq('Hello Romain !!')
+      end
+      specify { expect($test).to_not respond_to 'output=' }
+    end
+    after :all do
+      File::unlink($template_file) if File::exist?($template_file)
+      $test = nil
+    end
+  end
+end

data/templates/report.txt

@@ -6,6 +6,7 @@ Command : %%CMD_NAME%%
 full command line : %%CMD_LINE%%
 Description : %%DESC%%
 errorcode : %%STATUS%%
+Execution time (sec) : %%EXEC_TIME%%
 
 STDOUT:
 -------

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-splash
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Romain GEORGES
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-04 00:00:00.000000000 Z
+date: 2020-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +164,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-description: Prometheus Logs and Batchs supervision over PushGateway
+description: Prometheus Logs and Batchs supervision over PushGateway and commands
+  orchestration
 email:
 - gems@ultragreen.net
 executables:
@@ -150,14 +179,21 @@ files:
 - Rakefile
 - bin/splash
 - config/splash.yml
+- lib/splash/backends.rb
+- lib/splash/backends/file.rb
+- lib/splash/backends/redis.rb
 - lib/splash/commands.rb
 - lib/splash/config.rb
 - lib/splash/constants.rb
 - lib/splash/controller.rb
 - lib/splash/helpers.rb
 - lib/splash/logs.rb
+- lib/splash/orchestrator.rb
 - lib/splash/templates.rb
+- lib/splash/transports.rb
+- lib/splash/transports/rabbitmq.rb
 - prometheus-splash.gemspec
+- spec/templates_spec.rb
 - templates/report.txt
 - templates/splashd.service
 - ultragreen_roodi_coding_convention.yml
@@ -183,6 +219,7 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Supervision with Prometheus of Logs and Asynchronous tasks for Services or
-  Hosts
-test_files: []
+summary: Supervision with Prometheus of Logs and Asynchronous tasks orchestration
+  for Services or Hosts
+test_files:
+- spec/templates_spec.rb