sensu 0.13.0.alpha.2-java

data/lib/sensu/cli.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+require 'sensu/logger/constants'
+
+module Sensu
+  class CLI
+    def self.read(arguments=ARGV)
+      options = Hash.new
+      optparse = OptionParser.new do |opts|
+        opts.on('-h', '--help', 'Display this message') do
+          puts opts
+          exit
+        end
+        opts.on('-V', '--version', 'Display version') do
+          puts VERSION
+          exit
+        end
+        opts.on('-c', '--config FILE', 'Sensu JSON config FILE') do |file|
+          options[:config_file] = file
+        end
+        opts.on('-d', '--config_dir DIR[,DIR]', 'DIR or comma-delimited DIR list for Sensu JSON config files') do |dir|
+          options[:config_dirs] = dir.split(',')
+        end
+        opts.on('-e', '--extension_dir DIR', 'DIR for Sensu extensions') do |dir|
+          options[:extension_dir] = dir
+        end
+        opts.on('-l', '--log FILE', 'Log to a given FILE. Default: STDOUT') do |file|
+          options[:log_file] = file
+        end
+        opts.on('-L', '--log_level LEVEL', 'Log severity LEVEL') do |level|
+          log_level = level.to_s.downcase.to_sym
+          unless Logger::LEVELS.include?(log_level)
+            puts 'Unknown log level: ' + level.to_s
+            exit 1
+          end
+          options[:log_level] = log_level
+        end
+        opts.on('-v', '--verbose', 'Enable verbose logging') do
+          options[:log_level] = :debug
+        end
+        opts.on('-b', '--background', 'Fork into the background') do
+          options[:daemonize] = true
+        end
+        opts.on('-p', '--pid_file FILE', 'Write the PID to a given FILE') do |file|
+          options[:pid_file] = file
+        end
+      end
+      optparse.parse!(arguments)
+      options
+    end
+  end
+end

data/lib/sensu/client.rb

@@ -0,0 +1,261 @@
+require 'sensu/daemon'
+require 'sensu/socket'
+
+module Sensu
+  class Client
+    include Daemon
+
+    attr_accessor :safe_mode
+
+    def self.run(options={})
+      client = self.new(options)
+      EM::run do
+        client.start
+        client.setup_signal_traps
+      end
+    end
+
+    def initialize(options={})
+      super
+      @safe_mode = @settings[:client][:safe_mode] || false
+      @checks_in_progress = Array.new
+    end
+
+    def publish_keepalive
+      keepalive = @settings[:client].merge({
+        :version => VERSION,
+        :timestamp => Time.now.to_i
+      })
+      payload = redact_sensitive(keepalive, @settings[:client][:redact])
+      @logger.debug('publishing keepalive', {
+        :payload => payload
+      })
+      @transport.publish(:direct, 'keepalives', MultiJson.dump(payload)) do |info|
+        if info[:error]
+          @logger.error('failed to publish keepalive', {
+            :payload => payload,
+            :error => info[:error].to_s
+          })
+        end
+      end
+    end
+
+    def setup_keepalives
+      @logger.debug('scheduling keepalives')
+      publish_keepalive
+      @timers[:run] << EM::PeriodicTimer.new(20) do
+        unless @state == :paused
+          publish_keepalive
+        end
+      end
+    end
+
+    def publish_result(check)
+      payload = {
+        :client => @settings[:client][:name],
+        :check => check
+      }
+      @logger.info('publishing check result', {
+        :payload => payload
+      })
+      @transport.publish(:direct, 'results', MultiJson.dump(payload)) do |info|
+        if info[:error]
+          @logger.error('failed to publish check result', {
+            :payload => payload,
+            :error => info[:error].to_s
+          })
+        end
+      end
+    end
+
+    def substitute_command_tokens(check)
+      unmatched_tokens = Array.new
+      substituted = check[:command].gsub(/:::([^:]*?):::/) do
+        token, default = $1.to_s.split('|', -1)
+        matched = token.split('.').inject(@settings[:client]) do |client, attribute|
+          if client[attribute].nil?
+            default.nil? ? break : default
+          else
+            client[attribute]
+          end
+        end
+        if matched.nil?
+          unmatched_tokens << token
+        end
+        matched
+      end
+      [substituted, unmatched_tokens]
+    end
+
+    def execute_check_command(check)
+      @logger.debug('attempting to execute check command', {
+        :check => check
+      })
+      unless @checks_in_progress.include?(check[:name])
+        @checks_in_progress << check[:name]
+        command, unmatched_tokens = substitute_command_tokens(check)
+        if unmatched_tokens.empty?
+          check[:executed] = Time.now.to_i
+          started = Time.now.to_f
+          Spawn.process(command, :timeout => check[:timeout]) do |output, status|
+            check[:duration] = ('%.3f' % (Time.now.to_f - started)).to_f
+            check[:output] = output
+            check[:status] = status
+            publish_result(check)
+            @checks_in_progress.delete(check[:name])
+          end
+        else
+          check[:output] = 'Unmatched command tokens: ' + unmatched_tokens.join(', ')
+          check[:status] = 3
+          check[:handle] = false
+          publish_result(check)
+          @checks_in_progress.delete(check[:name])
+        end
+      else
+        @logger.warn('previous check command execution in progress', {
+          :check => check
+        })
+      end
+    end
+
+    def run_check_extension(check)
+      @logger.debug('attempting to run check extension', {
+        :check => check
+      })
+      check[:executed] = Time.now.to_i
+      extension = @extensions[:checks][check[:name]]
+      extension.safe_run do |output, status|
+        check[:output] = output
+        check[:status] = status
+        publish_result(check)
+      end
+    end
+
+    def process_check(check)
+      @logger.debug('processing check', {
+        :check => check
+      })
+      if check.has_key?(:command)
+        if @settings.check_exists?(check[:name])
+          check.merge!(@settings[:checks][check[:name]])
+          execute_check_command(check)
+        elsif @safe_mode
+          check[:output] = 'Check is not locally defined (safe mode)'
+          check[:status] = 3
+          check[:handle] = false
+          check[:executed] = Time.now.to_i
+          publish_result(check)
+        else
+          execute_check_command(check)
+        end
+      else
+        if @extensions.check_exists?(check[:name])
+          run_check_extension(check)
+        else
+          @logger.warn('unknown check extension', {
+            :check => check
+          })
+        end
+      end
+    end
+
+    def setup_subscriptions
+      @logger.debug('subscribing to client subscriptions')
+      @settings[:client][:subscriptions].each do |subscription|
+        @logger.debug('subscribing to a subscription', {
+          :subscription => subscription
+        })
+        funnel = [@settings[:client][:name], VERSION, Time.now.to_i].join('-')
+        @transport.subscribe(:fanout, subscription, funnel) do |message_info, message|
+          check = MultiJson.load(message)
+          @logger.info('received check request', {
+            :check => check
+          })
+          process_check(check)
+        end
+      end
+    end
+
+    def schedule_checks(checks)
+      check_count = 0
+      stagger = testing? ? 0 : 2
+      checks.each do |check|
+        check_count += 1
+        scheduling_delay = stagger * check_count % 30
+        @timers[:run] << EM::Timer.new(scheduling_delay) do
+          interval = testing? ? 0.5 : check[:interval]
+          @timers[:run] << EM::PeriodicTimer.new(interval) do
+            unless @state == :paused
+              check[:issued] = Time.now.to_i
+              process_check(check.dup)
+            end
+          end
+        end
+      end
+    end
+
+    def setup_standalone
+      @logger.debug('scheduling standalone checks')
+      standard_checks = @settings.checks.select do |check|
+        check[:standalone]
+      end
+      extension_checks = @extensions.checks.select do |check|
+        check[:standalone] && check[:interval].is_a?(Integer)
+      end
+      schedule_checks(standard_checks + extension_checks)
+    end
+
+    def setup_sockets
+      options = @settings[:client][:socket] || Hash.new
+      options[:bind] ||= '127.0.0.1'
+      options[:port] ||= 3030
+      @logger.debug('binding client tcp and udp sockets', {
+        :options => options
+      })
+      EM::start_server(options[:bind], options[:port], Socket) do |socket|
+        socket.logger = @logger
+        socket.settings = @settings
+        socket.transport = @transport
+      end
+      EM::open_datagram_socket(options[:bind], options[:port], Socket) do |socket|
+        socket.logger = @logger
+        socket.settings = @settings
+        socket.transport = @transport
+        socket.reply = false
+      end
+    end
+
+    def complete_checks_in_progress(&block)
+      @logger.info('completing checks in progress', {
+        :checks_in_progress => @checks_in_progress
+      })
+      retry_until_true do
+        if @checks_in_progress.empty?
+          block.call
+          true
+        end
+      end
+    end
+
+    def start
+      setup_transport
+      setup_keepalives
+      setup_subscriptions
+      setup_standalone
+      setup_sockets
+      super
+    end
+
+    def stop
+      @logger.warn('stopping')
+      @timers[:run].each do |timer|
+        timer.cancel
+      end
+      @transport.unsubscribe
+      complete_checks_in_progress do
+        @transport.close
+        super
+      end
+    end
+  end
+end

data/lib/sensu/constants.rb

@@ -0,0 +1,9 @@
+module Sensu
+  unless defined?(Sensu::VERSION)
+    VERSION = '0.13.0.alpha.2'
+
+    SEVERITIES = %w[ok warning critical unknown]
+
+    STOP_SIGNALS = %w[INT TERM]
+  end
+end

data/lib/sensu/daemon.rb

@@ -0,0 +1,221 @@
+require 'rubygems'
+
+gem 'multi_json', '1.10.1'
+
+gem 'sensu-em', '2.0.0'
+gem 'sensu-logger', '0.0.1'
+gem 'sensu-settings', '0.0.5'
+gem 'sensu-extension', '0.0.3'
+gem 'sensu-extensions', '0.0.5'
+gem 'sensu-transport', '0.0.2'
+gem 'sensu-spawn', '0.0.3'
+
+require 'time'
+require 'uri'
+
+require 'sensu/logger'
+require 'sensu/settings'
+require 'sensu/extensions'
+require 'sensu/transport'
+require 'sensu/spawn'
+
+require 'sensu/constants'
+require 'sensu/utilities'
+require 'sensu/cli'
+require 'sensu/redis'
+
+MultiJson.load_options = {:symbolize_keys => true}
+
+module Sensu
+  module Daemon
+    include Utilities
+
+    attr_reader :state
+
+    def initialize(options={})
+      @state = :initializing
+      @timers = {
+        :run => Array.new
+      }
+      setup_logger(options)
+      load_settings(options)
+      load_extensions(options)
+      setup_process(options)
+    end
+
+    def setup_logger(options={})
+      @logger = Logger.get(options)
+      @logger.setup_signal_traps
+    end
+
+    def log_concerns(concerns=[], level=:warn)
+      concerns.each do |concern|
+        message = concern.delete(:message)
+        @logger.send(level, message, redact_sensitive(concern))
+      end
+    end
+
+    def load_settings(options={})
+      @settings = Settings.get(options)
+      log_concerns(@settings.warnings)
+      failures = @settings.validate
+      unless failures.empty?
+        @logger.fatal('invalid settings')
+        log_concerns(failures, :fatal)
+        @logger.fatal('SENSU NOT RUNNING!')
+        exit 2
+      end
+    end
+
+    def load_extensions(options={})
+      @extensions = Extensions.get(options)
+      log_concerns(@extensions.warnings)
+      extension_settings = @settings.to_hash.dup
+      @extensions.all.each do |extension|
+        extension.logger = @logger
+        extension.settings = extension_settings
+      end
+    end
+
+    def setup_process(options)
+      if options[:daemonize]
+        daemonize
+      end
+      if options[:pid_file]
+        write_pid(options[:pid_file])
+      end
+    end
+
+    def start
+      @state = :running
+    end
+
+    def pause
+      @state = :paused
+    end
+
+    def resume
+      @state = :running
+    end
+
+    def stop
+      @state = :stopped
+      @logger.warn('stopping reactor')
+      EM::stop_event_loop
+    end
+
+    def setup_signal_traps
+      @signals = Array.new
+      STOP_SIGNALS.each do |signal|
+        Signal.trap(signal) do
+          @signals << signal
+        end
+      end
+      EM::PeriodicTimer.new(1) do
+        signal = @signals.shift
+        if STOP_SIGNALS.include?(signal)
+          @logger.warn('received signal', {
+            :signal => signal
+          })
+          stop
+        end
+      end
+    end
+
+    def setup_transport
+      if @settings[:transport].is_a?(Hash)
+        transport_name = @settings[:transport][:name]
+      end
+      transport_name ||= 'rabbitmq'
+      transport_settings = @settings[transport_name.to_sym]
+      @logger.debug('connecting to transport', {
+        :name => transport_name,
+        :settings => transport_settings
+      })
+      @transport = Transport.connect(transport_name, transport_settings)
+      @transport.logger = @logger
+      @transport.on_error do |error|
+        @logger.fatal('transport connection error', {
+          :error => error.to_s
+        })
+        stop
+      end
+      @transport.before_reconnect do
+        unless testing?
+          @logger.warn('reconnecting to transport')
+          pause
+        end
+      end
+      @transport.after_reconnect do
+        @logger.info('reconnected to transport')
+        resume
+      end
+    end
+
+    def setup_redis
+      @logger.debug('connecting to redis', {
+        :settings => @settings[:redis]
+      })
+      @redis = Redis.connect(@settings[:redis])
+      @redis.on_error do |error|
+        @logger.fatal('redis connection error', {
+          :error => error.to_s
+        })
+        stop
+      end
+      @redis.before_reconnect do
+        unless testing?
+          @logger.warn('reconnecting to redis')
+          pause
+        end
+      end
+      @redis.after_reconnect do
+        @logger.info('reconnected to redis')
+        resume
+      end
+    end
+
+    private
+
+    def write_pid(file)
+      begin
+        File.open(file, 'w') do |pid_file|
+          pid_file.puts(Process.pid)
+        end
+      rescue
+        @logger.fatal('could not write to pid file', {
+          :pid_file => file
+        })
+        @logger.fatal('SENSU NOT RUNNING!')
+        exit 2
+      end
+    end
+
+    def daemonize
+      Kernel.srand
+      if Kernel.fork
+        exit
+      end
+      unless Process.setsid
+        @logger.fatal('cannot detach from controlling terminal')
+        @logger.fatal('SENSU NOT RUNNING!')
+        exit 2
+      end
+      Signal.trap('SIGHUP', 'IGNORE')
+      if Kernel.fork
+        exit
+      end
+      Dir.chdir('/')
+      ObjectSpace.each_object(IO) do |io|
+        unless [STDIN, STDOUT, STDERR].include?(io)
+          begin
+            unless io.closed?
+              io.close
+            end
+          rescue
+          end
+        end
+      end
+    end
+  end
+end