prometheus-splash 0.4.5 → 0.6.1

data/lib/splash/config/flush.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+# Base Splash module
+module Splash
+
+  # module for Configuration utilities
+  module ConfigUtilities
+    include Splash::Constants
+
+    # clean backend action method
+    # @param [Hash] options
+    # @option options [Symbol] :name the name of the backend (:redis, :file)
+    # @return [Hash] An Exiter case hash (:quiet_exit or :configuration_error)
+    def flush_backend(options ={})
+      config = get_config
+      self.extend Splash::Backends
+      self.extend Splash::Loggers
+      log = get_logger
+      log.info "Splash backend flushing"
+      name  = (options[:name])? options[:name] : :execution_trace
+      backend = get_backend name
+      if backend.flush then
+        return { :case => :quiet_exit, :more => "Splash backend #{name.to_s} flushed" }
+      else
+        return { :case => :configuration_error, :more => "Splash backend #{name.to_s} can't be flushed" }
+      end
+    end
+
+  end
+end

data/lib/splash/config/sanitycheck.rb

@@ -1,12 +1,17 @@
 # coding: utf-8
+
+# Base Splash module
 module Splash
+
+  # moudle for Configuration utilities
   module ConfigUtilities
     include Splash::Constants
 
 
 
     # Sanitycheck action method for testing installation of Splash
-    # @return [Integer] an errorcode value
+    # @param [Hash] options
+    # @return [Hash] An Exiter case hash (:splash_sanitycheck_success or :splash_sanitycheck_error)
     def checkconfig(options ={})
       self.extend Splash::Loggers
       log = get_logger
@@ -45,7 +50,7 @@ module Splash
       end
 
       target = "Prometheus PushGateway Service running"
-      if verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
+      if verify_service url: config.prometheus_pushgateway_url then
         log.ok target
       else
         log.ko target

data/lib/splash/config/service.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+# Base Splash module
+module Splash
+
+  # moudle for Configuration utilities
+  module ConfigUtilities
+    include Splash::Constants
+    include Splash::Helpers
+
+
+    # clean backend configured
+    # @param [Hash] options
+    # @option options [Symbol] :name the name of the backend (:redis, :file)
+    # @return [Hash] An Exiter case hash (:quiet_exit or :configuration_error)
+    def addservice(options = {})
+      local_service_file = search_file_in_gem "prometheus-splash", "templates/splashd.service"
+      config = get_config
+      self.extend Splash::Loggers
+      log = get_logger
+      log.info "Splashd Systemd Service installation"
+      service_file = "splashd.service"
+      systemd_path = "/etc/systemd/system"
+      return { :case => :options_incompatibility, :more => "Systemd not avaible on this System" } if verify_folder({ :name => systemd_path}) == [:inexistant]
+      log.item "Installing service file : #{service_file} in #{systemd_path}"
+      if install_file source: local_service_file, target: "#{systemd_path}/#{service_file}", mode: "755", owner: config.user_root, group: config.group_root then
+        return { :case => :quiet_exit, :more => "Splashd Systemd service installed" }
+      else
+        return { :case => :error_exit, :more => "Splashd Systemd service could not be installed" }
+      end
+    end
+  end
+end

data/lib/splash/config/setup.rb

@@ -1,13 +1,18 @@
-
 # coding: utf-8
 
-
+# Base Splash module
 module Splash
+
+  # moudle for Configuration utilities
   module ConfigUtilities
     include Splash::Constants
     include Splash::Helpers
+
+
     # Setup action method for installing Splash
-    # @return [Integer] an errorcode value
+    # @param [Hash] options
+    # @option options [Symbol] :preserve flag to preserve config file during setup
+    # @return [Hash] An Exiter case hash (:splash_setup_success or :splash_setup_error)
     def setupsplash(options = {})
       conf_in_path = search_file_in_gem "prometheus-splash", "config/splash.yml"
       full_res = 0

data/lib/splash/constants.rb

@@ -1,20 +1,31 @@
 # coding: utf-8
+
+# base Splash module / namespace
 module Splash
+
+  # Constants namespace
   module Constants
-    VERSION = "0.4.5"
+
+    # Current splash version
+    VERSION = "0.6.1"
 
     # the path to th config file, not overridable by config
     CONFIG_FILE = "/etc/splash.yml"
     # the default execution trace_path if backend file
     TRACE_PATH="/var/run/splash"
+    # the default pid file path
+    PID_PATH="/var/run"
 
 
     # default scheduling criteria for log monitoring
     DAEMON_LOGMON_SCHEDULING={ :every => '20s'}
+    # default scheduling criteria for  metrics notifications
+    DAEMON_METRICS_SCHEDULING={ :every => '15s'}
+    # default scheduling criteria for process monitoring
+    DAEMON_PROCMON_SCHEDULING={ :every => '20s'}
+
     # the display name of daemon in proc info (ps/top)
     DAEMON_PROCESS_NAME="Splash : daemon."
-    # the default pid file path
-    DAEMON_PID_PATH="/var/run"
     # the default pid file name
     DAEMON_PID_FILE="splash.pid"
     # the default sdtout trace file
@@ -31,10 +42,11 @@ module Splash
     # type of licence
     LICENSE="BSD-2-Clause"
 
-    # the default prometheus pushgateway host
-    PROMETHEUS_PUSHGATEWAY_HOST = "localhost"
-    # the default prometheus pushgateway port
-    PROMETHEUS_PUSHGATEWAY_PORT = "9091"
+    # the default prometheus pushgateway URL
+    PROMETHEUS_PUSHGATEWAY_URL = 'http://localhost:9090/'
+
+    # the default prometheus URL
+    PROMETHEUS_URL = "http://localhost:9090/"
 
     # the default path fo execution report template
     EXECUTION_TEMPLATE="/etc/splash_execution_report.tpl"
@@ -50,11 +62,28 @@ module Splash
                           :active => :rabbitmq,
                           :rabbitmq => { :port => 5672, :host => "localhost", :vhost => '/'} }
 
-    LOGGERS_STRUCT = { :list => [:cli,:daemon, :dual],
+    # loggers default settings
+    LOGGERS_STRUCT = { :list => [:cli,:daemon, :dual, :web],
                        :default => :cli,
                        :level => :info,
                        :daemon => {:file => '/var/log/splash.log'},
+                       :web => {:file => '/var/log/splash_web.log'},
                        :cli => {:color => true, :emoji => true }  }
 
+    WEBADMIN_IP = "127.0.0.1"
+    WEBADMIN_PORT = "9234"
+    WEBADMIN_PROXY = false
+    # the display name of daemon in proc info (ps/top)
+    WEBADMIN_PROCESS_NAME="Splash : WebAdmin."
+    # the default pid file path
+    WEBADMIN_PID_PATH="/var/run"
+    # the default pid file name
+    WEBADMIN_PID_FILE="splash.pid"
+    # the default sdtout trace file
+    WEBADMIN_STDOUT_TRACE="stdout.txt"
+    # the default sdterr trace file
+    WEBADMIN_STDERR_TRACE="stderr.txt"
+
+
   end
 end

data/lib/splash/daemon.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+require File.dirname(__FILE__) + '/daemon/orchestrator.rb'
+require File.dirname(__FILE__) + '/daemon/metrics.rb'
+require File.dirname(__FILE__) + '/daemon/controller.rb'
+
+# Dir[File.dirname(__FILE__) + '/daemon/*.rb'].each {|file| require file  }

data/lib/splash/daemon/controller.rb

@@ -0,0 +1,136 @@
+# coding: utf-8
+require 'splash/daemon/orchestrator'
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module Daemon
+
+    # Daemon Controller Module
+    module Controller
+      include Splash::Constants
+      include Splash::Helpers
+      include Splash::Config
+      include Splash::Exiter
+      include Splash::Loggers
+      include Splash::Daemon::Orchestrator
+
+      # Start the Splash Daemon
+      # @param [Hash] options
+      # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
+      # @option options [Symbol] :foreground run daemon in foreground
+      # @option options [Symbol] :purge clean input queue for daemon on configured transport
+      # @return [Hash] Exiter Case (:quiet_exit, :already_exist, :unknown_error or other)
+      def startdaemon(options = {})
+        config = get_config
+        log = get_logger
+        log.level = :fatal if options[:quiet]
+        unless verify_service url: config.prometheus_pushgateway_url then
+          return {:case => :service_dependence_missing, :more => 'Prometheus Gateway'}
+        end
+        realpid = get_processes pattern: get_config.daemon_process_name
+        foreground  = get_processes patterns: [ "splash", "foreground" ]
+        unless foreground.empty? or options[:foreground] then
+          return {:case => :already_exist, :more => "Splash Process already launched on foreground "}
+        end
+
+        unless File::exist? config.daemon_full_pid_path then
+          unless realpid.empty? then
+            return {:case => :already_exist, :more => "Splash Process already launched "}
+          end
+          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
+          daemon_config = {:description => config.daemon_process_name,
+              :pid_file => config.daemon_full_pid_path,
+              :stdout_trace => config.daemon_full_stdout_trace_path,
+              :stderr_trace => config.daemon_full_stderr_trace_path,
+              :foreground => options[:foreground]
+            }
+
+          ["int","term","hup"].each do |type| daemon_config["sig#{type}_handler".to_sym] = Proc::new {  ObjectSpace.each_object(Splash::Daemon::Orchestrator::Scheduler).first.terminate } end
+          res = daemonize daemon_config do
+              Scheduler::new options
+          end
+          sleep 1
+          if res == 0 then
+            pid = `cat #{config.daemon_full_pid_path}`.to_i
+            log.ok "Splash Daemon Started, with PID : #{pid}"
+            return {:case => :quiet_exit, :more => "Splash Daemon successfully loaded."}
+          else
+            return {:case => :unknown_error, :more => "Splash Daemon loading error, see logs for more details."}
+          end
+
+        else
+          return {:case => :already_exist, :more => "Pid File, please verify if Splash daemon is running."}
+        end
+      end
+
+      # Stop the Splash Daemon
+      # @param [Hash] options
+      # @option options [Symbol] :quiet activate quiet mode for log (limit to :fatal)
+      # @return [Hash] Exiter Case (:quiet_exit, :not_found, other)
+      def stopdaemon(options = {})
+          config = get_config
+          log = get_logger
+          log.level = :fatal if options[:quiet]
+          if File.exist?(config.daemon_full_pid_path) then
+            begin
+              pid = `cat #{config.daemon_full_pid_path}`.to_i
+              Process.kill("TERM", pid)
+              acase = {:case => :quiet_exit, :more => 'Splash stopped succesfully'}
+            rescue Errno::ESRCH
+              acase =  {:case => :not_found, :more => "Process of PID : #{pid} not found"}
+            end
+            FileUtils::rm config.daemon_full_pid_path if File::exist? config.daemon_full_pid_path
+          else
+            acase =  {:case => :not_found, :more => "Splash is not running"}
+          end
+          return acase
+      end
+
+      # Status of the Splash Daemon, display status
+      # @param [Hash] options ignored
+      # @return [Hash] Exiter Case (:status_ko, :status_ok)
+      def statusdaemon(options = {})
+        log = get_logger
+        config = get_config
+        pid = realpid = ''
+        pid = `cat #{config.daemon_full_pid_path}`.to_s if File.exist?(config.daemon_full_pid_path)
+        listpid = get_processes({ :pattern => get_config.daemon_process_name})
+        pid.chomp!
+        if listpid.empty? then
+          realpid = ''
+        else
+          realpid = listpid.first
+        end
+        unless realpid.empty? then
+          log.item "Splash Process is running with PID #{realpid} "
+        else
+          log.item 'Splash Process not found '
+        end
+        unless pid.empty? then
+          log.item "and PID file exist with PID #{pid}"
+        else
+          log.item "and PID file don't exist"
+        end
+        if pid == realpid then
+          return {:case => :status_ok }
+        elsif pid.empty? then
+          return {:case => :status_ko, :more => "PID File error, you have to kill process manualy, with : '(sudo )kill -TERM #{realpid}'"}
+        elsif realpid.empty? then
+          return {:case => :status_ko, :more => "Process Splash Dameon missing, run 'splash daemon stop' to reload properly"}
+        end
+      end
+
+    end
+  end
+end

data/lib/splash/daemon/metrics.rb

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module Daemon
+
+    # Metrics management modulefor Splash daemon
+    module Metrics
+      include Splash::Constants
+      include Splash::Helpers
+      include Splash::Config
+      include Splash::Loggers
+
+      @@manager=nil
+
+      # metrics manager factory
+      # @return [Splash::Daemon::Metrics::Manager]
+      def get_metrics_manager
+        return @@manager ||= Manager::new
+      end
+
+      # Metrics Manager (collect and sending to Prometheus)
+      class Manager
+
+        # metric : commands executions count during Splash daemon uptime
+        attr_reader :execution_count
+        # metric : logs monitoring count during Splash daemon uptime
+        attr_reader :monitoring_logs_count
+        # metric : processes monitoring count during Splash daemon uptime
+        attr_reader :monitoring_processes_count
+
+        # Constructor prepare prometheus-client, defined metrics and init attributes
+        def initialize
+          @config = get_config
+          @starttime = Time.now
+          @execution_count = 0
+          @monitoring_logs_count = 0
+          @monitoring_processes_count = 0
+
+
+          @registry = Prometheus::Client::Registry::new
+          @metric_uptime = Prometheus::Client::Gauge.new(:splash_uptime, docstring: 'SPLASH self metric uptime')
+          @metric_execution = Prometheus::Client::Gauge.new(:splash_execution, docstring: 'SPLASH self metric total commands execution count')
+          @metric_logs_monitoring = Prometheus::Client::Gauge.new(:splash_logs_monitoring, docstring: 'SPLASH self metric total logs monitoring count')
+          @metric_processes_monitoring = Prometheus::Client::Gauge.new(:splash_processes_monitoring, docstring: 'SPLASH self metric total processes monitoring count')
+          @registry.register(@metric_uptime)
+          @registry.register(@metric_execution)
+          @registry.register(@metric_logs_monitoring)
+          @registry.register(@metric_processes_monitoring)
+        end
+
+        # virtual accessor uptime
+        def uptime
+          return Time.now - @starttime
+        end
+
+        # increment metric : execution_count
+        def inc_execution
+          @execution_count += 1
+        end
+
+        # increment metric : monitoring_logs_count
+        def inc_logs_monitoring
+          @monitoring_logs_count += 1
+        end
+
+        # increment metric : monitoring_processes_count
+        def inc_processes_monitoring
+          @monitoring_processes_count += 1
+        end
+
+        # Send metrics to Prometheus PushGateway
+        # @return [Hash] Exiter case ( :service_dependence_missing , :quiet_exit)
+        def notify
+          log = get_logger
+          session  = get_session
+          unless verify_service url: @config.prometheus_pushgateway_url then
+            return  { :case => :service_dependence_missing, :more => "Prometheus Notification not send." }
+          end
+
+          log.debug "Sending Splash self metrics to PushGateway." , session
+          @metric_uptime.set uptime
+          @metric_execution.set execution_count
+          @metric_logs_monitoring.set monitoring_logs_count
+          @metric_processes_monitoring.set monitoring_processes_count
+
+          hostname = Socket.gethostname
+          url = @config.prometheus_pushgateway_url
+          Prometheus::Client::Push.new('Splash',hostname, url).add(@registry)
+          log.debug "Sending to Prometheus PushGateway done.", session
+          return {:case => :quiet_exit }
+        end
+
+
+
+      end
+
+
+    end
+  end
+end

data/lib/splash/daemon/orchestrator.rb

@@ -0,0 +1,182 @@
+# coding: utf-8
+Dir[File.dirname(__FILE__) + '/orchestrator/*.rb'].each {|file| require file  }
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module Daemon
+
+    # orchestrator specific module
+    module Orchestrator
+
+      # Splash Scheduler object
+      class Scheduler
+        include Splash::Constants
+        include Splash::Helpers
+        include Splash::Config
+        include Splash::Transports
+        include Splash::Daemon::Orchestrator::Grammar
+        include Splash::Loggers
+        include Splash::Logs
+        include Splash::Processes
+        include Splash::Commands
+        include Splash::Sequences
+
+        # Constructor prepare the Scheduler
+        # commands Schedules
+        # logs monitorings
+        # process monitorings
+        # @param [Hash] options
+        # @option options [Symbol] :scheduling activate commands scheduling
+        def initialize(options = {})
+          @log = get_logger
+          self.extend Splash::Daemon::Metrics
+          @metric_manager = get_metrics_manager
+          $stdout.sync = true
+          $stderr.sync = true
+          @server  = Rufus::Scheduler::new
+          @server.extend SchedulerHooks
+          @config = get_config
+
+          @log.info "Splash Orchestrator starting :"
+          if options[:scheduling] then
+            @log.item "Initializing commands Scheduling."
+            init_commands_scheduling
+            init_sequences_scheduling
+          end
+
+          if @config.logs.empty? then
+            @log.item "No logs to monitor"
+          else
+            sched,value = @config.daemon_procmon_scheduling.flatten
+            @log.item "Initializing logs monitorings & notifications."
+            @log_result = LogScanner::new
+            @server.send sched,value do
+              begin
+                session = get_session
+                @metric_manager.inc_logs_monitoring
+                @log.trigger "Logs monitoring for Scheduling : #{sched.to_s} #{value.to_s}", session
+                @log_result.analyse
+                @log_result.notify :session => session
+              rescue Errno::ECONNREFUSED
+                @log.error "PushGateway seems to be done, please start it.", session
+              end
+            end
+          end
+
+          if @config.processes.empty? then
+            @log.item "No processes to monitor"
+          else
+            sched,value = @config.daemon_logmon_scheduling.flatten
+            @log.item "Initializing processes monitorings & notifications."
+            @process_result = ProcessScanner::new
+            @server.send sched,value do
+              begin
+                session = get_session
+                @metric_manager.inc_processes_monitoring
+                @log.trigger "Processes monitoring for Scheduling : #{sched.to_s} #{value.to_s}", session
+                @process_result.analyse
+                @process_result.notify :session => session
+              rescue Errno::ECONNREFUSED
+                @log.error "PushGateway seems to be done, please start it.", session
+              end
+            end
+          end
+
+
+          sched,value = @config.daemon_metrics_scheduling.flatten
+          @log.item "Initializing Splash metrics notifications."
+          @server.send sched,value do
+            begin
+              @metric_manager.notify
+            rescue Errno::ECONNREFUSED
+              @log.error "PushGateway seems to be done, please start it."
+            end
+          end
+
+          hostname = Socket.gethostname
+          transport = get_default_subscriber queue: "splash.#{hostname}.input"
+          if transport.class == Hash and transport.include? :case then
+            splash_exit transport
+          end
+          transport.subscribe(:block => true) do |delivery_info, properties, body|
+            content = YAML::load(body)
+            session = get_session
+            content[:session] = session
+            if VERBS.include? content[:verb]
+              @log.receive "Valid remote order, verb : #{content[:verb].to_s}", session
+              res = self.send content[:verb], content
+              get_default_client.publish queue: content[:return_to], message: res.to_yaml
+              @log.send "Result to #{content[:return_to]}.", session
+            else
+              @log.receive "INVALID remote order, verb : #{content[:verb].to_s}", session
+              get_default_client.publish queue: content[:return_to], message: "Unkown verb #{content[:verb]}".to_yaml
+            end
+          end
+        end
+
+        # Stop the Splash daemon gracefully
+        # @return [hash] Exiter Case :quiet_exit
+        def terminate
+          @log.info "Splash daemon shutdown"
+          @server.shutdown
+          change_logger logger: :cli
+          splash_exit case: :quiet_exit
+        end
+
+        private
+        # prepare commands Scheduling
+        def init_commands_scheduling
+          config = get_config.commands
+          commands = config.select{|key,value| value.include? :schedule}.keys
+          commands.each do |command|
+            sched,value = config[command][:schedule].flatten
+            @log.arrow "Scheduling command #{command.to_s}"
+            @server.send sched,value do
+              session  = get_session
+              @log.trigger "Executing Scheduled command #{command.to_s} for Scheduling : #{sched.to_s} #{value.to_s}", session
+              execute command: command.to_s, session: session
+            end
+          end
+
+        end
+
+
+        # prepare sequences Scheduling
+        def init_sequences_scheduling
+          config = get_config.sequences
+          sequences = config.select{|key,value| value.include? :schedule}.keys
+          sequences.each do |sequence|
+            sched,value = config[sequence][:schedule].flatten
+            @log.arrow "Scheduling sequence #{sequence.to_s}"
+            @server.send sched,value do
+              session  = get_session
+              @log.trigger "Executing Scheduled sequence #{sequence.to_s} for Scheduling : #{sched.to_s} #{value.to_s}", session
+              run_seq name: sequence.to_s, session: session
+            end
+          end
+
+        end
+
+
+
+        # execute_command verb : execute command specified in payload
+        # @param [Hash] options
+        # @option options [Symbol] :command the name of the command
+        # @option options [Symbol] :ack ack flag to inhibit execution and send ack to Prometheus (0)
+        # @return [Hash] Exiter case
+        def execute(options)
+          command =  CommandWrapper::new(options[:command])
+          if options[:ack] then
+          else
+            @metric_manager.inc_execution
+            return command.call_and_notify trace: true, notify: true, callback: true, session: options[:session]
+          end
+        end
+
+      end
+
+    end
+  end
+end