class Splash::Daemon::Orchestrator::Scheduler

Splash Scheduler object

Public Class Methods

new(options = {}) click to toggle source

Constructor prepare the Scheduler commands Schedules logs monitorings process monitorings @param [Hash] options @option options [Symbol] :scheduling activate commands scheduling

# File lib/splash/daemon/orchestrator.rb, line 32
def initialize(options = {})
  @log = get_logger
  self.extend Splash::Daemon::Metrics
  @session = get_session
  @metric_manager = get_metrics_manager(@session)
  $stdout.sync = true
  $stderr.sync = true
  @server  = Rufus::Scheduler::new
  @server.extend SchedulerHooks
  @config = get_config
  @scheduling = options[:scheduling]

  @log.info "Splash Orchestrator starting :"
  if @scheduling then
    @log.item "Initializing Sequences & commands Scheduling."
    init_commands_scheduling
    init_sequences_scheduling
  end

  init_logs_monitoring_scheduling
  init_process_monitoring_scheduling
  init_metrics_scheduling
  init_daemon_subscriber

end

Public Instance Methods

terminate() click to toggle source

Stop the Splash daemon gracefully @return [hash] Exiter Case :quiet_exit

# File lib/splash/daemon/orchestrator.rb, line 64
def terminate
  @log.info "Splash daemon shutdown"
  @server.shutdown
  change_logger logger: :cli
  splash_exit case: :quiet_exit
end

Private Instance Methods

execute(options) click to toggle source

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

# File lib/splash/daemon/orchestrator.rb, line 210
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
init_commands_scheduling() click to toggle source

prepare commands Scheduling

# File lib/splash/daemon/orchestrator.rb, line 157
def init_commands_scheduling
  commands = @config.commands.select{|command| command.include? :schedule}
  commands.each do |command|
    sched,value = command[:schedule].flatten
    @log.arrow "Scheduling command #{command[:name].to_s}"
    @server.send sched,value do
      session  = get_session
      @log.trigger "Executing Scheduled command #{command[:name].to_s} for Scheduling : #{sched.to_s} #{value.to_s}", session
      execute command: command[:name].to_s, session: session
    end
  end
end
init_daemon_subscriber() click to toggle source

prepare main daemon subscriber

# File lib/splash/daemon/orchestrator.rb, line 74
def init_daemon_subscriber
  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 unless content[:return_to] == :ignore
      @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
init_logs_monitoring_scheduling() click to toggle source

prepare logs monitoring sheduling

# File lib/splash/daemon/orchestrator.rb, line 97
def init_logs_monitoring_scheduling
  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
end
init_metrics_scheduling() click to toggle source

prepare metrics sheduling

# File lib/splash/daemon/orchestrator.rb, line 142
def init_metrics_scheduling
  sched,value = @config.daemon_metrics_scheduling.flatten
  @log.item "Initializing Splash metrics notifications."
  @server.send sched,value do
    begin
      @log.trigger "Splash Metrics monitoring for Scheduling : #{sched.to_s} #{value.to_s}", @session
      @metric_manager.notify
    rescue Errno::ECONNREFUSED
      @log.error "PushGateway seems to be done, please start it."
    end
  end
end
init_process_monitoring_scheduling() click to toggle source

prepare process monitoring sheduling

# File lib/splash/daemon/orchestrator.rb, line 119
def init_process_monitoring_scheduling
  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
end
init_sequences_scheduling() click to toggle source

prepare sequences Scheduling

# File lib/splash/daemon/orchestrator.rb, line 172
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
reset_orchestrator() click to toggle source

reset the orchestrator @return [Hash] Exiter case

# File lib/splash/daemon/orchestrator.rb, line 188
def reset_orchestrator
  @server.shutdown
  @server = Rufus::Scheduler::new
  @server.extend SchedulerHooks
  @config = rehash_config
  @log.info "Splash Orchestrator re-hashing :"
  if @scheduling then
    @log.item "Re-Initializing Sequences & commands Scheduling."
    init_commands_scheduling
    init_sequences_scheduling
  end
  init_logs_monitoring_scheduling
  init_process_monitoring_scheduling
  init_metrics_scheduling
end