sensu 0.12.6 → 0.13.0.alpha

data/lib/sensu/cli.rb

@@ -1,4 +1,5 @@
 require 'optparse'
+require 'sensu/logger/constants'
 
 module Sensu
   class CLI
@@ -27,7 +28,7 @@ module Sensu
         end
         opts.on('-L', '--log_level LEVEL', 'Log severity LEVEL') do |level|
           log_level = level.to_s.downcase.to_sym
-          unless LOG_LEVELS.include?(log_level)
+          unless Logger::LEVELS.include?(log_level)
             puts 'Unknown log level: ' + level.to_s
             exit 1
           end

data/lib/sensu/client.rb

@@ -1,9 +1,9 @@
-require File.join(File.dirname(__FILE__), 'base')
-require File.join(File.dirname(__FILE__), 'socket')
+require 'sensu/daemon'
+require 'sensu/socket'
 
 module Sensu
   class Client
-    include Utilities
+    include Daemon
 
     attr_accessor :safe_mode
 
@@ -11,63 +11,40 @@ module Sensu
       client = self.new(options)
       EM::run do
         client.start
-        client.trap_signals
+        client.setup_signal_traps
       end
     end
 
     def initialize(options={})
-      base = Base.new(options)
-      @logger = base.logger
-      @settings = base.settings
-      @extensions = base.extensions
-      base.setup_process
-      @extensions.load_settings(@settings.to_hash)
-      @timers = Array.new
-      @checks_in_progress = Array.new
+      super
       @safe_mode = @settings[:client][:safe_mode] || false
-    end
-
-    def setup_rabbitmq
-      @logger.debug('connecting to rabbitmq', {
-        :settings => @settings[:rabbitmq]
-      })
-      @rabbitmq = RabbitMQ.connect(@settings[:rabbitmq])
-      @rabbitmq.on_error do |error|
-        @logger.fatal('rabbitmq connection error', {
-          :error => error.to_s
-        })
-        stop
-      end
-      @rabbitmq.before_reconnect do
-        @logger.warn('reconnecting to rabbitmq')
-      end
-      @rabbitmq.after_reconnect do
-        @logger.info('reconnected to rabbitmq')
-      end
-      @amq = @rabbitmq.channel
+      @checks_in_progress = Array.new
     end
 
     def publish_keepalive
-      keepalive = @settings[:client].merge(:timestamp => Time.now.to_i)
+      keepalive = @settings[:client].merge({
+        :version => VERSION,
+        :timestamp => Time.now.to_i
+      })
       payload = redact_sensitive(keepalive, @settings[:client][:redact])
       @logger.debug('publishing keepalive', {
         :payload => payload
       })
-      begin
-        @amq.direct('keepalives').publish(Oj.dump(payload))
-      rescue AMQ::Client::ConnectionClosedError => error
-        @logger.error('failed to publish keepalive', {
-          :payload => payload,
-          :error => error.to_s
-        })
+      @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 << EM::PeriodicTimer.new(20) do
-        if @rabbitmq.connected?
+      @timers[:run] << EM::PeriodicTimer.new(20) do
+        unless @state == :paused
           publish_keepalive
         end
       end
@@ -81,19 +58,19 @@ module Sensu
       @logger.info('publishing check result', {
         :payload => payload
       })
-      begin
-        @amq.direct('results').publish(Oj.dump(payload))
-      rescue AMQ::Client::ConnectionClosedError => error
-        @logger.error('failed to publish check result', {
-          :payload => payload,
-          :error => error.to_s
-        })
+      @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
+      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?
@@ -117,27 +94,16 @@ module Sensu
       unless @checks_in_progress.include?(check[:name])
         @checks_in_progress << check[:name]
         command, unmatched_tokens = substitute_command_tokens(check)
-        check[:executed] = Time.now.to_i
         if unmatched_tokens.empty?
-          execute = Proc.new do
-            @logger.debug('executing check command', {
-              :check => check
-            })
-            started = Time.now.to_f
-            begin
-              check[:output], check[:status] = IO.popen(command, 'r', check[:timeout])
-            rescue => error
-              check[:output] = 'Unexpected error: ' + error.to_s
-              check[:status] = 2
-            end
+          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
-          end
-          publish = Proc.new do |check|
+            check[:output] = output
+            check[:status] = status
             publish_result(check)
             @checks_in_progress.delete(check[:name])
           end
-          EM::defer(execute, publish)
         else
           check[:output] = 'Unmatched command tokens: ' + unmatched_tokens.join(', ')
           check[:status] = 3
@@ -195,16 +161,13 @@ module Sensu
 
     def setup_subscriptions
       @logger.debug('subscribing to client subscriptions')
-      @check_request_queue = @amq.queue('', :auto_delete => true) do |queue|
-        @settings[:client][:subscriptions].each do |exchange_name|
-          @logger.debug('binding queue to exchange', {
-            :queue_name => queue.name,
-            :exchange_name => exchange_name
-          })
-          queue.bind(@amq.fanout(exchange_name))
-        end
-        queue.subscribe do |payload|
-          check = Oj.load(payload)
+      @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
           })
@@ -219,12 +182,12 @@ module Sensu
       checks.each do |check|
         check_count += 1
         scheduling_delay = stagger * check_count % 30
-        @timers << EM::Timer.new(scheduling_delay) do
+        @timers[:run] << EM::Timer.new(scheduling_delay) do
           interval = testing? ? 0.5 : check[:interval]
-          @timers << EM::PeriodicTimer.new(interval) do
-            if @rabbitmq.connected?
+          @timers[:run] << EM::PeriodicTimer.new(interval) do
+            unless @state == :paused
               check[:issued] = Time.now.to_i
-              process_check(check)
+              process_check(check.dup)
             end
           end
         end
@@ -252,27 +215,16 @@ module Sensu
       EM::start_server(options[:bind], options[:port], Socket) do |socket|
         socket.logger = @logger
         socket.settings = @settings
-        socket.amq = @amq
+        socket.transport = @transport
       end
       EM::open_datagram_socket(options[:bind], options[:port], Socket) do |socket|
         socket.logger = @logger
         socket.settings = @settings
-        socket.amq = @amq
+        socket.transport = @transport
         socket.reply = false
       end
     end
 
-    def unsubscribe
-      @logger.warn('unsubscribing from client subscriptions')
-      if @rabbitmq.connected?
-        @check_request_queue.unsubscribe
-      else
-        @check_request_queue.before_recovery do
-          @check_request_queue.unsubscribe
-        end
-      end
-    end
-
     def complete_checks_in_progress(&block)
       @logger.info('completing checks in progress', {
         :checks_in_progress => @checks_in_progress
@@ -286,43 +238,23 @@ module Sensu
     end
 
     def start
-      setup_rabbitmq
+      setup_transport
       setup_keepalives
       setup_subscriptions
       setup_standalone
       setup_sockets
+      super
     end
 
     def stop
       @logger.warn('stopping')
-      @timers.each do |timer|
+      @timers[:run].each do |timer|
         timer.cancel
       end
-      unsubscribe
+      @transport.unsubscribe
       complete_checks_in_progress do
-        @extensions.stop_all do
-          @rabbitmq.close
-          @logger.warn('stopping reactor')
-          EM::stop_event_loop
-        end
-      end
-    end
-
-    def trap_signals
-      @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
+        @transport.close
+        super
       end
     end
   end

data/lib/sensu/constants.rb

@@ -1,12 +1,6 @@
 module Sensu
   unless defined?(Sensu::VERSION)
-    VERSION = '0.12.6'
-
-    LOG_LEVELS = [:debug, :info, :warn, :error, :fatal]
-
-    SETTINGS_CATEGORIES = [:checks, :filters, :mutators, :handlers]
-
-    EXTENSION_CATEGORIES = [:generics, :checks, :mutators, :handlers]
+    VERSION = '0.13.0.alpha'
 
     SEVERITIES = %w[ok warning critical unknown]
 

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.4'
+gem 'sensu-extension', '0.0.3'
+gem 'sensu-extensions', '0.0.4'
+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.load(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.load(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