prometheus-splash 0.5.0 → 0.7.0

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/{controller.rb → daemon/controller.rb}

@@ -1,19 +1,32 @@
 # coding: utf-8
+require 'splash/daemon/orchestrator'
+
+# base Splash module
 module Splash
-  module LogsMonitor
-    module DaemonController
+
+  # global daemon module
+  module Daemon
+
+    # Daemon Controller Module
+    module Controller
       include Splash::Constants
       include Splash::Helpers
       include Splash::Config
-      include Splash::Orchestrator
       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 host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
+        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
@@ -22,7 +35,7 @@ module Splash
           return {:case => :already_exist, :more => "Splash Process already launched on foreground "}
         end
 
-        unless File::exist? config.full_pid_path then
+        unless File::exist? config.daemon_full_pid_path then
           unless realpid.empty? then
             return {:case => :already_exist, :more => "Splash Process already launched "}
           end
@@ -37,19 +50,19 @@ module Splash
             end
           end
           daemon_config = {:description => config.daemon_process_name,
-              :pid_file => config.full_pid_path,
-              :stdout_trace => config.full_stdout_trace_path,
-              :stderr_trace => config.full_stderr_trace_path,
+              :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::Orchestrator::Scheduler).first.shutdown } end
+          ["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.full_pid_path}`.to_i
+            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
@@ -61,30 +74,37 @@ module Splash
         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.full_pid_path) then
+          if File.exist?(config.daemon_full_pid_path) then
             begin
-              pid = `cat #{config.full_pid_path}`.to_i
+              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.full_pid_path if File::exist? config.full_pid_path
+            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.full_pid_path}`.to_s if File.exist?(config.full_pid_path)
+        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

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

data/lib/splash/daemon/orchestrator/grammar.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+# base Splash module
+module Splash
+
+  # global daemon module
+  module Daemon
+
+    # orchestrator specific module
+    module Orchestrator
+
+      # Orchestrator grammar method defiition  module
+      module Grammar
+
+        include Splash::Config
+        include Splash::Loggers
+
+        # list of known verbs for Splash orchestrator
+        VERBS=[:ping,:list_commands,:execute_command,:ack_command, :shutdown]
+
+        # shutdown verb : stop the Splash daemon gracefully
+        # @param [Hash] content message content Hash Structure, ignored
+        # @return [Hash] Exiter Case :quiet_exit
+        def shutdown(content)
+          terminate
+        end
+
+        # ping verb : return pong to hostname precise in payload
+        # @param [Hash] content message content Hash Structure, include  mandatory payload[:hostname]
+        # @return [String] the pong
+        def ping(content)
+          return "Pong : #{content[:payload][:hostname]} !"
+        end
+
+        # list_commands verb : return the list of specified commands in local Splash
+        # @param [Hash] content message content Hash Structure, ignored
+        # @return [Hash] structure of commands
+        def list_commands(content)
+          return get_config.commands
+        end
+
+        # ack_command verb : send ack to Prometheus, for command specified in payload
+        # @param [Hash] content message content Hash Structure, include  mandatory payload[:name]
+        # @return [Hash] Exiter case
+        def ack_command(content)
+          return execute command: content[:payload][:name], ack: true
+        end
+
+        # execute_command verb : execute command specified in payload
+        # @param [Hash] content message content Hash Structure, include  mandatory payload[:name]
+        # @return [Hash] Exiter case
+        def execute_command(content)
+          payload = content[:payload]
+          unless get_config.commands.include? payload[:name].to_sym
+            @log.item "Command not found", content[:session]
+            return { :case => :not_found }
+          end
+          if payload.include? :schedule then
+            sched,value = payload[:schedule].flatten
+            @log.schedule "remote call command #{payload[:name]}, scheduling : #{sched.to_s} #{value}", content[:session]
+            @server.send sched,value do
+              @log.trigger "Executing Scheduled command #{payload[:name]} for Scheduling : #{sched.to_s} #{value}", content[:session]
+              execute command: payload[:name], session: content[:session]
+            end
+            return { :case => :quiet_exit }
+          else
+            @log.info "Execute direct command",  content[:session]
+            res = execute command: payload[:name], session: content[:session]
+            return res
+          end
+        end
+
+      end
+    end
+  end
+end