sensu 0.13.0.alpha.2-java

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Sonian Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,11 @@
+![sensu](https://raw.github.com/sensu/sensu/master/sensu-logo.png)
+
+A monitoring framework that aims to be simple, malleable, and scalable.
+
+[![Build Status](https://secure.travis-ci.org/sensu/sensu.png)](https://travis-ci.org/sensu/sensu)
+
+## Documentation
+  Please refer to the [Sensu Docs](http://docs.sensuapp.org/).
+
+## License
+  Sensu is released under the [MIT license](https://raw.github.com/sensu/sensu/master/MIT-LICENSE.txt).

data/bin/sensu-api

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+  $: << File.dirname(__FILE__) + '/../lib'
+end
+
+require 'sensu/api'
+
+options = Sensu::CLI.read
+Sensu::API.run(options)

data/bin/sensu-client

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+  $: << File.dirname(__FILE__) + '/../lib'
+end
+
+require 'sensu/client'
+
+options = Sensu::CLI.read
+Sensu::Client.run(options)

data/bin/sensu-server

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+  $: << File.dirname(__FILE__) + '/../lib'
+end
+
+require 'sensu/server'
+
+options = Sensu::CLI.read
+Sensu::Server.run(options)

data/lib/sensu.rb

@@ -0,0 +1,3 @@
+module Sensu
+  # A monitoring framework that aims to be simple, malleable, & scalable.
+end

data/lib/sensu/api.rb

@@ -0,0 +1,674 @@
+require 'sensu/daemon'
+
+gem 'sinatra', '1.3.5'
+gem 'async_sinatra', '1.0.0'
+
+unless RUBY_PLATFORM =~ /java/
+  gem 'thin', '1.5.0'
+  require 'thin'
+end
+
+require 'sinatra/async'
+
+module Sensu
+  class API < Sinatra::Base
+    register Sinatra::Async
+
+    class << self
+      include Daemon
+
+      def run(options={})
+        bootstrap(options)
+        setup_process(options)
+        EM::run do
+          start
+          setup_signal_traps
+        end
+      end
+
+      def on_reactor_run
+        EM::next_tick do
+          setup_redis
+          set :redis, @redis
+          setup_transport
+          set :transport, @transport
+        end
+      end
+
+      def bootstrap(options)
+        setup_logger(options)
+        set :logger, @logger
+        load_settings(options)
+        set :checks, @settings[:checks]
+        set :all_checks, @settings.checks
+        if @settings[:api][:user] && @settings[:api][:password]
+          use Rack::Auth::Basic do |user, password|
+            user == @settings[:api][:user] && password == @settings[:api][:password]
+          end
+        end
+        on_reactor_run
+        self
+      end
+
+      def start_server
+        Thin::Logging.silent = true
+        bind = @settings[:api][:bind] || '0.0.0.0'
+        @thin = Thin::Server.new(bind, @settings[:api][:port], self)
+        @thin.start
+      end
+
+      def stop_server(&block)
+        @thin.stop
+        retry_until_true do
+          unless @thin.running?
+            block.call
+            true
+          end
+        end
+      end
+
+      def start
+        start_server
+        super
+      end
+
+      def stop
+        @logger.warn('stopping')
+        stop_server do
+          @redis.close
+          @transport.close
+          super
+        end
+      end
+
+      def test(options={})
+        bootstrap(options)
+        start
+      end
+    end
+
+    configure do
+      disable :protection
+      disable :show_exceptions
+    end
+
+    not_found do
+      ''
+    end
+
+    error do
+      ''
+    end
+
+    helpers do
+      def request_log_line
+        settings.logger.info([env['REQUEST_METHOD'], env['REQUEST_PATH']].join(' '), {
+          :remote_address => env['REMOTE_ADDR'],
+          :user_agent => env['HTTP_USER_AGENT'],
+          :request_method => env['REQUEST_METHOD'],
+          :request_uri => env['REQUEST_URI'],
+          :request_body => env['rack.input'].read
+        })
+        env['rack.input'].rewind
+      end
+
+      def bad_request!
+        ahalt 400
+      end
+
+      def not_found!
+        ahalt 404
+      end
+
+      def unavailable!
+        ahalt 503
+      end
+
+      def created!(response)
+        status 201
+        body response
+      end
+
+      def accepted!(response)
+        status 202
+        body response
+      end
+
+      def issued!
+        accepted!(MultiJson.dump(:issued => Time.now.to_i))
+      end
+
+      def no_content!
+        status 204
+        body ''
+      end
+
+      def read_data(rules={}, &block)
+        begin
+          data = MultiJson.load(env['rack.input'].read)
+          valid = rules.all? do |key, rule|
+            data[key].is_a?(rule[:type]) || (rule[:nil_ok] && data[key].nil?)
+          end
+          if valid
+            block.call(data)
+          else
+            bad_request!
+          end
+        rescue MultiJson::ParseError
+          bad_request!
+        end
+      end
+
+      def integer_parameter(parameter)
+        parameter =~ /^[0-9]+$/ ? parameter.to_i : nil
+      end
+
+      def pagination(items)
+        limit = integer_parameter(params[:limit])
+        offset = integer_parameter(params[:offset]) || 0
+        unless limit.nil?
+          headers['X-Pagination'] = MultiJson.dump(
+            :limit => limit,
+            :offset => offset,
+            :total => items.size
+          )
+          paginated = items.slice(offset, limit)
+          Array(paginated)
+        else
+          items
+        end
+      end
+
+      def transport_info(&block)
+        info = {
+          :keepalives => {
+            :messages => nil,
+            :consumers => nil
+          },
+          :results => {
+            :messages => nil,
+            :consumers => nil
+          },
+          :connected => settings.transport.connected?
+        }
+        if settings.transport.connected?
+          settings.transport.stats('keepalives') do |stats|
+            info[:keepalives] = stats
+            settings.transport.stats('results') do |stats|
+              info[:results] = stats
+              block.call(info)
+            end
+          end
+        else
+          block.call(info)
+        end
+      end
+
+      def resolve_event(event_json)
+        event = MultiJson.load(event_json)
+        check = event[:check].merge(
+          :output => 'Resolving on request of the API',
+          :status => 0,
+          :issued => Time.now.to_i,
+          :executed => Time.now.to_i,
+          :force_resolve => true
+        )
+        check.delete(:history)
+        payload = {
+          :client => event[:client][:name],
+          :check => check
+        }
+        settings.logger.info('publishing check result', {
+          :payload => payload
+        })
+        settings.transport.publish(:direct, 'results', MultiJson.dump(payload)) do |info|
+          if info[:error]
+            settings.logger.error('failed to publish check result', {
+              :payload => payload,
+              :error => info[:error].to_s
+            })
+          end
+        end
+      end
+    end
+
+    before do
+      request_log_line
+      content_type 'application/json'
+    end
+
+    aget '/info/?' do
+      transport_info do |info|
+        response = {
+          :sensu => {
+            :version => VERSION
+          },
+          :transport => info,
+          :redis => {
+            :connected => settings.redis.connected?
+          }
+        }
+        body MultiJson.dump(response)
+      end
+    end
+
+    aget '/health/?' do
+      if settings.redis.connected? && settings.transport.connected?
+        healthy = Array.new
+        min_consumers = integer_parameter(params[:consumers])
+        max_messages = integer_parameter(params[:messages])
+        transport_info do |info|
+          if min_consumers
+            healthy << (info[:keepalives][:consumers] >= min_consumers)
+            healthy << (info[:results][:consumers] >= min_consumers)
+          end
+          if max_messages
+            healthy << (info[:keepalives][:messages] <= max_messages)
+            healthy << (info[:results][:messages] <= max_messages)
+          end
+          healthy.all? ? no_content! : unavailable!
+        end
+      else
+        unavailable!
+      end
+    end
+
+    aget '/clients/?' do
+      response = Array.new
+      settings.redis.smembers('clients') do |clients|
+        clients = pagination(clients)
+        unless clients.empty?
+          clients.each_with_index do |client_name, index|
+            settings.redis.get('client:' + client_name) do |client_json|
+              response << MultiJson.load(client_json)
+              if index == clients.size - 1
+                body MultiJson.dump(response)
+              end
+            end
+          end
+        else
+          body MultiJson.dump(response)
+        end
+      end
+    end
+
+    aget %r{/clients?/([\w\.-]+)/?$} do |client_name|
+      settings.redis.get('client:' + client_name) do |client_json|
+        unless client_json.nil?
+          body client_json
+        else
+          not_found!
+        end
+      end
+    end
+
+    aget %r{/clients/([\w\.-]+)/history/?$} do |client_name|
+      response = Array.new
+      settings.redis.smembers('history:' + client_name) do |checks|
+        unless checks.empty?
+          checks.each_with_index do |check_name, index|
+            history_key = 'history:' + client_name + ':' + check_name
+            settings.redis.lrange(history_key, -21, -1) do |history|
+              history.map! do |status|
+                status.to_i
+              end
+              execution_key = 'execution:' + client_name + ':' + check_name
+              settings.redis.get(execution_key) do |last_execution|
+                unless history.empty? || last_execution.nil?
+                  item = {
+                    :check => check_name,
+                    :history => history,
+                    :last_execution => last_execution.to_i,
+                    :last_status => history.last
+                  }
+                  response << item
+                end
+                if index == checks.size - 1
+                  body MultiJson.dump(response)
+                end
+              end
+            end
+          end
+        else
+          body MultiJson.dump(response)
+        end
+      end
+    end
+
+    adelete %r{/clients?/([\w\.-]+)/?$} do |client_name|
+      settings.redis.get('client:' + client_name) do |client_json|
+        unless client_json.nil?
+          settings.redis.hgetall('events:' + client_name) do |events|
+            events.each do |check_name, event_json|
+              resolve_event(event_json)
+            end
+            EM::Timer.new(5) do
+              client = MultiJson.load(client_json)
+              settings.logger.info('deleting client', {
+                :client => client
+              })
+              settings.redis.srem('clients', client_name) do
+                settings.redis.del('client:' + client_name)
+                settings.redis.del('events:' + client_name)
+                settings.redis.smembers('history:' + client_name) do |checks|
+                  checks.each do |check_name|
+                    settings.redis.del('history:' + client_name + ':' + check_name)
+                    settings.redis.del('execution:' + client_name + ':' + check_name)
+                  end
+                  settings.redis.del('history:' + client_name)
+                end
+              end
+            end
+            issued!
+          end
+        else
+          not_found!
+        end
+      end
+    end
+
+    aget '/checks/?' do
+      body MultiJson.dump(settings.all_checks)
+    end
+
+    aget %r{/checks?/([\w\.-]+)/?$} do |check_name|
+      if settings.checks[check_name]
+        response = settings.checks[check_name].merge(:name => check_name)
+        body MultiJson.dump(response)
+      else
+        not_found!
+      end
+    end
+
+    apost '/request/?' do
+      rules = {
+        :check => {:type => String, :nil_ok => false},
+        :subscribers => {:type => Array, :nil_ok => true}
+      }
+      read_data(rules) do |data|
+        if settings.checks[data[:check]]
+          check = settings.checks[data[:check]]
+          subscribers = data[:subscribers] || check[:subscribers] || Array.new
+          payload = {
+            :name => data[:check],
+            :command => check[:command],
+            :issued => Time.now.to_i
+          }
+          settings.logger.info('publishing check request', {
+            :payload => payload,
+            :subscribers => subscribers
+          })
+          subscribers.uniq.each do |exchange_name|
+            settings.transport.publish(:fanout, exchange_name, MultiJson.dump(payload)) do |info|
+              if info[:error]
+                settings.logger.error('failed to publish check request', {
+                  :exchange_name => exchange_name,
+                  :payload => payload,
+                  :error => info[:error].to_s
+                })
+              end
+            end
+          end
+          issued!
+        else
+          not_found!
+        end
+      end
+    end
+
+    aget '/events/?' do
+      response = Array.new
+      settings.redis.smembers('clients') do |clients|
+        unless clients.empty?
+          clients.each_with_index do |client_name, index|
+            settings.redis.hgetall('events:' + client_name) do |events|
+              events.each do |check_name, event_json|
+                response << MultiJson.load(event_json)
+              end
+              if index == clients.size - 1
+                body MultiJson.dump(response)
+              end
+            end
+          end
+        else
+          body MultiJson.dump(response)
+        end
+      end
+    end
+
+    aget %r{/events/([\w\.-]+)/?$} do |client_name|
+      response = Array.new
+      settings.redis.hgetall('events:' + client_name) do |events|
+        events.each do |check_name, event_json|
+          response << MultiJson.load(event_json)
+        end
+        body MultiJson.dump(response)
+      end
+    end
+
+    aget %r{/events?/([\w\.-]+)/([\w\.-]+)/?$} do |client_name, check_name|
+      settings.redis.hgetall('events:' + client_name) do |events|
+        event_json = events[check_name]
+        unless event_json.nil?
+          body event_json
+        else
+          not_found!
+        end
+      end
+    end
+
+    adelete %r{/events?/([\w\.-]+)/([\w\.-]+)/?$} do |client_name, check_name|
+      settings.redis.hgetall('events:' + client_name) do |events|
+        if events.include?(check_name)
+          resolve_event(events[check_name])
+          issued!
+        else
+          not_found!
+        end
+      end
+    end
+
+    apost '/resolve/?' do
+      rules = {
+        :client => {:type => String, :nil_ok => false},
+        :check => {:type => String, :nil_ok => false}
+      }
+      read_data(rules) do |data|
+        settings.redis.hgetall('events:' + data[:client]) do |events|
+          if events.include?(data[:check])
+            resolve_event(events[data[:check]])
+            issued!
+          else
+            not_found!
+          end
+        end
+      end
+    end
+
+    aget '/aggregates/?' do
+      response = Array.new
+      settings.redis.smembers('aggregates') do |checks|
+        unless checks.empty?
+          checks.each_with_index do |check_name, index|
+            settings.redis.smembers('aggregates:' + check_name) do |aggregates|
+              aggregates.reverse!
+              aggregates.map! do |issued|
+                issued.to_i
+              end
+              item = {
+                :check => check_name,
+                :issued => aggregates
+              }
+              response << item
+              if index == checks.size - 1
+                body MultiJson.dump(response)
+              end
+            end
+          end
+        else
+          body MultiJson.dump(response)
+        end
+      end
+    end
+
+    aget %r{/aggregates/([\w\.-]+)/?$} do |check_name|
+      settings.redis.smembers('aggregates:' + check_name) do |aggregates|
+        unless aggregates.empty?
+          aggregates.reverse!
+          aggregates.map! do |issued|
+            issued.to_i
+          end
+          age = integer_parameter(params[:age])
+          if age
+            timestamp = Time.now.to_i - age
+            aggregates.reject! do |issued|
+              issued > timestamp
+            end
+          end
+          body MultiJson.dump(pagination(aggregates))
+        else
+          not_found!
+        end
+      end
+    end
+
+    adelete %r{/aggregates/([\w\.-]+)/?$} do |check_name|
+      settings.redis.smembers('aggregates:' + check_name) do |aggregates|
+        unless aggregates.empty?
+          aggregates.each do |check_issued|
+            result_set = check_name + ':' + check_issued
+            settings.redis.del('aggregation:' + result_set)
+            settings.redis.del('aggregate:' + result_set)
+          end
+          settings.redis.del('aggregates:' + check_name) do
+            settings.redis.srem('aggregates', check_name) do
+              no_content!
+            end
+          end
+        else
+          not_found!
+        end
+      end
+    end
+
+    aget %r{/aggregates?/([\w\.-]+)/([\w\.-]+)/?$} do |check_name, check_issued|
+      result_set = check_name + ':' + check_issued
+      settings.redis.hgetall('aggregate:' + result_set) do |aggregate|
+        unless aggregate.empty?
+          response = aggregate.inject(Hash.new) do |totals, (status, count)|
+            totals[status] = Integer(count)
+            totals
+          end
+          settings.redis.hgetall('aggregation:' + result_set) do |results|
+            parsed_results = results.inject(Array.new) do |parsed, (client_name, check_json)|
+              check = MultiJson.load(check_json)
+              parsed << check.merge(:client => client_name)
+            end
+            if params[:summarize]
+              options = params[:summarize].split(',')
+              if options.include?('output')
+                outputs = Hash.new(0)
+                parsed_results.each do |result|
+                  outputs[result[:output]] += 1
+                end
+                response[:outputs] = outputs
+              end
+            end
+            if params[:results]
+              response[:results] = parsed_results
+            end
+            body MultiJson.dump(response)
+          end
+        else
+          not_found!
+        end
+      end
+    end
+
+    apost %r{/stash(?:es)?/(.*)/?} do |path|
+      read_data do |data|
+        settings.redis.set('stash:' + path, MultiJson.dump(data)) do
+          settings.redis.sadd('stashes', path) do
+            created!(MultiJson.dump(:path => path))
+          end
+        end
+      end
+    end
+
+    aget %r{/stash(?:es)?/(.*)/?} do |path|
+      settings.redis.get('stash:' + path) do |stash_json|
+        unless stash_json.nil?
+          body stash_json
+        else
+          not_found!
+        end
+      end
+    end
+
+    adelete %r{/stash(?:es)?/(.*)/?} do |path|
+      settings.redis.exists('stash:' + path) do |stash_exists|
+        if stash_exists
+          settings.redis.srem('stashes', path) do
+            settings.redis.del('stash:' + path) do
+              no_content!
+            end
+          end
+        else
+          not_found!
+        end
+      end
+    end
+
+    aget '/stashes/?' do
+      response = Array.new
+      settings.redis.smembers('stashes') do |stashes|
+        unless stashes.empty?
+          stashes.each_with_index do |path, index|
+            settings.redis.get('stash:' + path) do |stash_json|
+              settings.redis.ttl('stash:' + path) do |ttl|
+                unless stash_json.nil?
+                  item = {
+                    :path => path,
+                    :content => MultiJson.load(stash_json),
+                    :expire => ttl
+                  }
+                  response << item
+                else
+                  settings.redis.srem('stashes', path)
+                end
+                if index == stashes.size - 1
+                  body MultiJson.dump(pagination(response))
+                end
+              end
+            end
+          end
+        else
+          body MultiJson.dump(response)
+        end
+      end
+    end
+
+    apost '/stashes/?' do
+      rules = {
+        :path => {:type => String, :nil_ok => false},
+        :content => {:type => Hash, :nil_ok => false},
+        :expire => {:type => Integer, :nil_ok => true}
+      }
+      read_data(rules) do |data|
+        stash_key = 'stash:' + data[:path]
+        settings.redis.set(stash_key, MultiJson.dump(data[:content])) do
+          settings.redis.sadd('stashes', data[:path]) do
+            response = MultiJson.dump(:path => data[:path])
+            if data[:expire]
+              settings.redis.expire(stash_key, data[:expire]) do
+                created!(response)
+              end
+            else
+              created!(response)
+            end
+          end
+        end
+      end
+    end
+  end
+end