prometheus-splash 0.4.5 → 0.6.1

data/lib/splash/controller.rb

@@ -1,90 +0,0 @@
-# coding: utf-8
-module Splash
-  module LogsMonitor
-    module DaemonController
-      include Splash::Constants
-      include Splash::Helpers
-      include Splash::Config
-      include Splash::Orchestrator
-      include Splash::Exiter
-      include Splash::Loggers
-
-      def startdaemon(options = {})
-        config = get_config
-        log = get_logger
-        unless verify_service host: config.prometheus_pushgateway_host ,port: config.prometheus_pushgateway_port then
-          return {:case => :service_dependence_missing, :more => 'Prometheus Gateway'}
-        end
-        unless File::exist? config.full_pid_path then
-          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,
-              :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
-          res = daemonize daemon_config do
-              Scheduler::new options
-          end
-          sleep 1
-          if res == 0 then
-            pid = `cat #{config.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
-
-      def stopdaemon(options = {})
-          config = get_config
-          if File.exist?(config.full_pid_path) then
-            begin
-              pid = `cat #{config.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
-          else
-            acase =  {:case => :not_found, :more => "Splash is not running"}
-          end
-          return acase
-      end
-
-      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)
-        realpid = get_process pattern: get_config.daemon_process_name
-        pid.chomp!
-        realpid.chomp!
-        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/orchestrator.rb

@@ -1,100 +0,0 @@
-# coding: utf-8
-Dir[File.dirname(__FILE__) + '/orchestrator/*.rb'].each {|file| require file  }
-
-
-
-module Splash
-  module Orchestrator
-
-    class Scheduler
-        include Splash::Constants
-        include Splash::Helpers
-        include Splash::Config
-        include Splash::Transports
-        include Splash::Orchestrator::Grammar
-        include Splash::Loggers
-
-        def initialize(options = {})
-          @log = get_logger
-          $stdout.sync = true
-          $stderr.sync = true
-          @server  = Rufus::Scheduler::new
-          @server.extend SchedulerHooks
-          @config = get_config
-          @result = LogScanner::new
-          @log.info "Splash Orchestrator starting :"
-          if options[:scheduling] then
-            @log.item "Initializing commands Scheduling."
-            init_commands_scheduling
-          end
-          sched,value = @config.daemon_logmon_scheduling.flatten
-          @log.item "Initializing logs monitorings & notifications."
-          @server.send sched,value do
-            begin
-              @log.trigger "Logs monitoring for Scheduling : #{sched.to_s} #{value.to_s}"
-              @result.analyse
-              @result.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)
-            if VERBS.include? content[:verb]
-              @log.receive "Valid remote order, verb : #{content[:verb].to_s}"
-              if content[:payload] then
-                res = self.send content[:verb], content[:payload]
-              else
-                res = self.send content[:verb]
-              end
-              get_default_client.publish queue: content[:return_to], message: res.to_yaml
-              @log.send "Result to #{content[:return_to]}."
-            else
-              @log.receive "INVALID remote order, verb : #{content[:verb].to_s}"
-              get_default_client.publish queue: content[:return_to], message: "Unkown verb #{content[:verb]}".to_yaml
-            end
-          end
-        end
-
-        def terminate
-          @log.info "Splash daemon shutdown"
-          @server.shutdown
-          change_logger logger: :cli
-          splash_exit case: :quiet_exit
-        end
-
-        private
-        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
-                @log.trigger "Executing Scheduled command #{command.to_s} for Scheduling : #{sched.to_s} #{value.to_s}"
-                execute command: command.to_s
-              end
-            end
-
-        end
-
-        def execute(options)
-          command =  Splash::CommandWrapper::new(options[:command])
-          if options[:ack] then
-            command.ack
-          else
-            return command.call_and_notify trace: true, notify: true, callback: true
-          end
-        end
-
-      end
-
-
-    end
-
-  end

data/lib/splash/orchestrator/grammar.rb

@@ -1,53 +0,0 @@
-# coding: utf-8
-module Splash
-  module Orchestrator
-    module Grammar
-
-      include Splash::Config
-      include Splash::Loggers
-
-
-      VERBS=[:ping,:list_commands,:execute_command,:ack_command, :shutdown]
-
-
-      def shutdown
-        terminate
-      end
-
-      def ping(payload)
-        return "Pong : #{payload[:hostname]} !"
-      end
-
-
-      def list_commands
-        return get_config.commands
-      end
-
-      def ack_command(payload)
-        return execute command: payload[:name], ack: true
-      end
-
-
-      def execute_command(payload)
-        unless get_config.commands.include? payload[:name].to_sym
-          @log.item "Command not found"
-          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}"
-          @server.send sched,value do
-            @log.trigger "Executing Scheduled command #{payload[:name]} for Scheduling : #{sched.to_s} #{value}"
-            execute command: payload[:name]
-          end
-          return { :case => :quiet_exit }
-        else
-          @log.info "Execute direct command"
-          res = execute command: payload[:name]
-          return res
-        end
-      end
-
-    end
-  end
-end

data/lib/splash/orchestrator/hooks.rb

@@ -1,16 +0,0 @@
-# coding: utf-8
-module Splash
-  module Orchestrator
-
-    module SchedulerHooks
-      def on_pre_trigger(job, trigger_time)
-
-      end
-
-      def on_post_trigger(job, trigger_time)
-
-      end
-
-    end
-  end
-end

data/templates/ansible-splash/inventory.prod

@@ -1,26 +0,0 @@
-# TEMPLATE
-[PROD:children]
-backend
-mq
-splash_nodes
-supervision_master
-supervision_gateway
-
-
-[backend]
-backend ansible_host=X.X.X.X
-
-[mq]
-mq ansible_host=X.X.X.X
-
-
-[splash_nodes]
-node1 ansible_host=X.X.X.X
-node2 ansible_host=X.X.X.X
-
-
-[supervision_gateway]
-pushgateway ansible_host=X.X.X.X
-
-[supervision_master]
-prometheus ansible_host=X.X.X.X