sensu 0.12.6 → 0.13.0.alpha

data/lib/sensu/base.rb

@@ -1,75 +0,0 @@
-require 'rubygems'
-
-gem 'oj', '2.0.9'
-gem 'eventmachine', '1.0.3'
-
-require 'time'
-require 'uri'
-require 'oj'
-
-require File.join(File.dirname(__FILE__), 'constants')
-require File.join(File.dirname(__FILE__), 'utilities')
-require File.join(File.dirname(__FILE__), 'cli')
-require File.join(File.dirname(__FILE__), 'logstream')
-require File.join(File.dirname(__FILE__), 'settings')
-require File.join(File.dirname(__FILE__), 'extensions')
-require File.join(File.dirname(__FILE__), 'process')
-require File.join(File.dirname(__FILE__), 'io')
-require File.join(File.dirname(__FILE__), 'rabbitmq')
-
-Oj.default_options = {:mode => :compat, :symbol_keys => true}
-
-module Sensu
-  class Base
-    def initialize(options={})
-      @options = options
-    end
-
-    def logger
-      logger = Logger.get
-      if @options[:log_level]
-        logger.level = @options[:log_level]
-      end
-      if @options[:log_file]
-        logger.reopen(@options[:log_file])
-      end
-      logger.setup_traps
-      logger
-    end
-
-    def settings
-      settings = Settings.new
-      settings.load_env
-      if @options[:config_file]
-        settings.load_file(@options[:config_file])
-      end
-      if @options[:config_dirs]
-        @options[:config_dirs].each do |config_dir|
-          settings.load_directory(config_dir)
-        end
-      end
-      settings.validate
-      settings.set_env
-      settings
-    end
-
-    def extensions
-      extensions = Extensions.new
-      if @options[:extension_dir]
-        extensions.require_directory(@options[:extension_dir])
-      end
-      extensions.load_all
-      extensions
-    end
-
-    def setup_process
-      process = Process.new
-      if @options[:daemonize]
-        process.daemonize
-      end
-      if @options[:pid_file]
-        process.write_pid(@options[:pid_file])
-      end
-    end
-  end
-end

data/lib/sensu/extensions.rb

@@ -1,162 +0,0 @@
-module Sensu
-  class Extensions
-    def initialize
-      @logger = Logger.get
-      @extensions = Hash.new
-      EXTENSION_CATEGORIES.each do |category|
-        @extensions[category] = Hash.new
-      end
-    end
-
-    def [](key)
-      @extensions[key]
-    end
-
-    EXTENSION_CATEGORIES.each do |category|
-      define_method(category) do
-        @extensions[category].map do |name, extension|
-          extension.definition
-        end
-      end
-
-      define_method(category.to_s.chop + '_exists?') do |name|
-        @extensions[category].has_key?(name)
-      end
-    end
-
-    def require_directory(directory)
-      path = directory.gsub(/\\(?=\S)/, '/')
-      Dir.glob(File.join(path, '**/*.rb')).each do |file|
-        begin
-          require File.expand_path(file)
-        rescue ScriptError => error
-          @logger.error('failed to require extension', {
-            :extension_file => file,
-            :error => error
-          })
-          @logger.warn('ignoring extension', {
-            :extension_file => file
-          })
-        end
-      end
-    end
-
-    def load_all
-      require_directory(File.join(File.dirname(__FILE__), 'extensions'))
-      EXTENSION_CATEGORIES.each do |category|
-        extension_type = category.to_s.chop
-        Extension.const_get(extension_type.capitalize).descendants.each do |klass|
-          extension = klass.new
-          extension.logger = @logger
-          @extensions[category][extension.name] = extension
-          loaded(extension_type, extension.name, extension.description)
-        end
-      end
-    end
-
-    def load_settings(settings={})
-      all_extensions.each do |extension|
-        extension.settings = settings
-      end
-    end
-
-    def stop_all(&block)
-      extensions = all_extensions
-      stopper = Proc.new do |extension|
-        if extension.nil?
-          block.call
-        else
-          extension.stop do
-            stopper.call(extensions.pop)
-          end
-        end
-      end
-      stopper.call(extensions.pop)
-    end
-
-    private
-
-    def all_extensions
-      all = @extensions.map do |category, extensions|
-        extensions.map do |name, extension|
-          extension
-        end
-      end
-      all.flatten
-    end
-
-    def loaded(type, name, description)
-      @logger.info('loaded extension', {
-        :type => type,
-        :name => name,
-        :description => description
-      })
-    end
-  end
-
-  module Extension
-    class Base
-      attr_accessor :logger, :settings
-
-      def initialize
-        EM::next_tick do
-          post_init
-        end
-      end
-
-      def name
-        'base'
-      end
-
-      def description
-        'extension description (change me)'
-      end
-
-      def definition
-        {
-          :type => 'extension',
-          :name => name
-        }
-      end
-
-      def post_init
-        true
-      end
-
-      def run(data=nil, &block)
-        block.call('noop', 0)
-      end
-
-      def stop(&block)
-        block.call
-      end
-
-      def [](key)
-        definition[key.to_sym]
-      end
-
-      def has_key?(key)
-        definition.has_key?(key.to_sym)
-      end
-
-      def safe_run(data=nil, &block)
-        begin
-          data ? run(data.dup, &block) : run(&block)
-        rescue => error
-          block.call(error.to_s, 2)
-        end
-      end
-
-      def self.descendants
-        ObjectSpace.each_object(Class).select do |klass|
-          klass < self
-        end
-      end
-    end
-
-    EXTENSION_CATEGORIES.each do |category|
-      extension_type = category.to_s.chop
-      Object.const_set(extension_type.capitalize, Class.new(Base))
-    end
-  end
-end

data/lib/sensu/extensions/handlers/debug.rb

@@ -1,17 +0,0 @@
-module Sensu
-  module Extension
-    class Debug < Handler
-      def name
-        'debug'
-      end
-
-      def description
-        'outputs json event data'
-      end
-
-      def run(event, &block)
-        block.call(event, 0)
-      end
-    end
-  end
-end

data/lib/sensu/extensions/mutators/only_check_output.rb

@@ -1,17 +0,0 @@
-module Sensu
-  module Extension
-    class OnlyCheckOutput < Mutator
-      def name
-        'only_check_output'
-      end
-
-      def description
-        'returns check output'
-      end
-
-      def run(event, &block)
-        block.call(event[:check][:output], 0)
-      end
-    end
-  end
-end

data/lib/sensu/io.rb

@@ -1,98 +0,0 @@
-gem 'em-worker', '0.0.2'
-
-require 'timeout'
-require 'em/worker'
-
-module Sensu
-  class IO
-    class << self
-      def popen(command, mode='r', timeout=nil, &block)
-        block ||= Proc.new {}
-        begin
-          if RUBY_VERSION < '1.9.3'
-            child = ::IO.popen(command + ' 2>&1', mode)
-            block.call(child)
-            wait_on_process(child, false)
-          else
-            options = {
-              :err => [:child, :out]
-            }
-            case RUBY_PLATFORM
-            when /(ms|cyg|bcc)win|mingw|win32/
-              shell = ['cmd', '/c']
-              options[:new_pgroup] = true
-            else
-              shell = ['sh', '-c']
-              options[:pgroup] = true
-            end
-            child = ::IO.popen(shell + [command, options], mode)
-            if timeout
-              Timeout.timeout(timeout) do
-                block.call(child)
-                wait_on_process(child)
-              end
-            else
-              block.call(child)
-              wait_on_process(child)
-            end
-          end
-        rescue Timeout::Error
-          kill_process_group(child.pid)
-          wait_on_process_group(child.pid)
-          ['Execution timed out', 2]
-        rescue => error
-          kill_process_group(child.pid)
-          wait_on_process_group(child.pid)
-          raise error
-        end
-      end
-
-      def async_popen(command, data=nil, timeout=nil, &block)
-        execute = Proc.new do
-          begin
-            popen(command, 'r+', timeout) do |child|
-              unless data.nil?
-                child.write(data.to_s)
-              end
-              child.close_write
-            end
-          rescue => error
-            [error.to_s, 2]
-          end
-        end
-        complete = Proc.new do |output, status|
-          block.call(output, status) if block
-        end
-        @async_popen_worker ||= EM::Worker.new
-        @async_popen_worker.enqueue(execute, complete)
-      end
-
-      private
-
-      def kill_process_group(group_id)
-        begin
-          ::Process.kill(9, -group_id)
-        rescue Errno::ESRCH, Errno::EPERM
-        end
-      end
-
-      def wait_on_process_group(group_id)
-        begin
-          loop do
-            ::Process.wait2(-group_id)
-          end
-        rescue Errno::ECHILD
-        end
-      end
-
-      def wait_on_process(process, wait_on_group=true)
-        output = process.read
-        _, status = ::Process.wait2(process.pid)
-        if wait_on_group
-          wait_on_process_group(process.pid)
-        end
-        [output, status.exitstatus || 2]
-      end
-    end
-  end
-end

data/lib/sensu/logstream.rb

@@ -1,93 +0,0 @@
-module Sensu
-  class LogStream
-    def initialize
-      @log_stream = EM::Queue.new
-      @log_level = :info
-      STDOUT.sync = true
-      STDERR.reopen(STDOUT)
-      setup_writer
-    end
-
-    def level=(level)
-      @log_level = level
-    end
-
-    def level_filtered?(level)
-      LOG_LEVELS.index(level) < LOG_LEVELS.index(@log_level)
-    end
-
-    def add(level, *arguments)
-      unless level_filtered?(level)
-        log_event = create_log_event(level, *arguments)
-        if EM::reactor_running?
-          @log_stream << log_event
-        else
-          puts log_event
-        end
-      end
-    end
-
-    LOG_LEVELS.each do |level|
-      define_method(level) do |*arguments|
-        add(level, *arguments)
-      end
-    end
-
-    def reopen(file)
-      @log_file = file
-      if File.writable?(file) || !File.exist?(file) && File.writable?(File.dirname(file))
-        STDOUT.reopen(file, 'a')
-        STDOUT.sync = true
-        STDERR.reopen(STDOUT)
-      else
-        error('log file is not writable', {
-          :log_file => file
-        })
-      end
-    end
-
-    def setup_traps
-      if Signal.list.include?('USR1')
-        Signal.trap('USR1') do
-          @log_level = @log_level == :info ? :debug : :info
-        end
-      end
-      if Signal.list.include?('USR2')
-        Signal.trap('USR2') do
-          if @log_file
-            reopen(@log_file)
-          end
-        end
-      end
-    end
-
-    private
-
-    def create_log_event(level, message, data=nil)
-      log_event = Hash.new
-      log_event[:timestamp] = Time.now.strftime("%Y-%m-%dT%H:%M:%S.%6N%z")
-      log_event[:level] = level
-      log_event[:message] = message
-      if data.is_a?(Hash)
-        log_event.merge!(data)
-      end
-      Oj.dump(log_event)
-    end
-
-    def setup_writer
-      writer = Proc.new do |log_event|
-        puts log_event
-        EM::next_tick do
-          @log_stream.pop(&writer)
-        end
-      end
-      @log_stream.pop(&writer)
-    end
-  end
-
-  class Logger
-    def self.get
-      @logger ||= LogStream.new
-    end
-  end
-end