flapjack 0.9.6 → 1.0.0rc1

data/lib/flapjack/gateways/api/entity_check_presenter.rb

@@ -1,218 +0,0 @@
-#!/usr/bin/env ruby
-
-# Formats entity/check data for presentation by the API methods in Flapjack::Gateways::API.
-
-require 'sinatra/base'
-
-require 'flapjack/data/entity_check'
-
-module Flapjack
-
-  module Gateways
-
-    class API < Sinatra::Base
-
-      class EntityCheckPresenter
-
-        def initialize(entity_check)
-          @entity_check = entity_check
-        end
-
-        def status
-          {'name'                              => @entity_check.check,
-           'state'                             => @entity_check.state,
-           'enabled'                           => @entity_check.enabled?,
-           'summary'                           => @entity_check.summary,
-           'details'                           => @entity_check.details,
-           'perfdata'                          => @entity_check.perfdata,
-           'in_unscheduled_maintenance'        => @entity_check.in_unscheduled_maintenance?,
-           'in_scheduled_maintenance'          => @entity_check.in_scheduled_maintenance?,
-           'last_update'                       => @entity_check.last_update,
-           'last_problem_notification'         => @entity_check.last_notification_for_state(:problem)[:timestamp],
-           'last_recovery_notification'        => @entity_check.last_notification_for_state(:recovery)[:timestamp],
-           'last_acknowledgement_notification' => @entity_check.last_notification_for_state(:acknowledgement)[:timestamp]}
-        end
-
-        def outages(start_time, end_time, options = {})
-          # hist_states is an array of hashes, with [state, timestamp, summary] keys
-          hist_states = @entity_check.historical_states(start_time, end_time)
-          return hist_states if hist_states.empty?
-
-          initial = @entity_check.historical_state_before(hist_states.first[:timestamp])
-          hist_states.unshift(initial) if initial
-
-          # TODO the following works, but isn't the neatest
-          num_states = hist_states.size
-
-          index = 0
-          result = []
-          obj = nil
-
-          while index < num_states do
-            last_obj = obj
-            obj = hist_states[index]
-            index += 1
-
-            next if obj[:state] == 'ok'
-
-            if last_obj && (last_obj[:state] == obj[:state])
-              # TODO maybe build up arrays of these instead, and leave calling
-              # classes to join them together if needed?
-              result.last[:summary] << " / #{obj[:summary]}"
-              result.last[:details] << " / #{obj[:details]}"
-              next
-            end
-
-            ts = obj[:timestamp]
-
-            obj_st  = (last_obj || !start_time) ? ts : [ts, start_time].max
-
-            next_ts_obj = hist_states[index..-1].detect {|hs| hs[:state] != obj[:state] }
-            obj_et  = next_ts_obj ? next_ts_obj[:timestamp] : end_time
-
-            obj_dur = obj_et ? obj_et - obj_st : nil
-
-            result << {:state      => obj[:state],
-                       :start_time => obj_st,
-                       :end_time   => obj_et,
-                       :duration   => obj_dur,
-                       :summary    => obj[:summary] || '',
-                       :details    => obj[:details] || ''
-                      }
-          end
-
-          result
-        end
-
-        def unscheduled_maintenances(start_time, end_time)
-          # unsched_maintenance is an array of hashes, with [duration, timestamp, summary] keys
-          unsched_maintenance = @entity_check.maintenances(start_time, end_time,
-            :scheduled => false)
-
-          # to see if we start in an unscheduled maintenance period, we must check all unscheduled
-          # maintenances before the period and their durations
-          start_in_unsched = start_time.nil? ? [] :
-            @entity_check.maintenances(nil, start_time, :scheduled => false).select {|pu|
-              pu[:end_time] >= start_time
-            }
-
-          start_in_unsched + unsched_maintenance
-        end
-
-        def scheduled_maintenances(start_time, end_time)
-          # sched_maintenance is an array of hashes, with [duration, timestamp, summary] keys
-          sched_maintenance = @entity_check.maintenances(start_time, end_time,
-            :scheduled => true)
-
-          # to see if we start in a scheduled maintenance period, we must check all scheduled
-          # maintenances before the period and their durations
-          start_in_sched = start_time.nil? ? [] :
-            @entity_check.maintenances(nil, start_time, :scheduled => true).select {|ps|
-              ps[:end_time] >= start_time
-            }
-
-          start_in_sched + sched_maintenance
-        end
-
-        # TODO test whether the below overlapping logic is prone to off-by-one
-        # errors; the numbers may line up more neatly if we consider outages to
-        # start one second after the maintenance period ends.
-        #
-        # TODO test performance with larger data sets
-        def downtime(start_time, end_time)
-          sched_maintenances = scheduled_maintenances(start_time, end_time)
-
-          outs = outages(start_time, end_time)
-
-          total_secs  = {}
-          percentages = {}
-
-          outs.collect {|obj| obj[:state]}.uniq.each do |st|
-            total_secs[st]  = 0
-            percentages[st] = (start_time.nil? || end_time.nil?) ? nil : 0
-          end
-
-          unless outs.empty?
-
-            # Initially we need to check for cases where a scheduled
-            # maintenance period is fully covered by an outage period.
-            # We then create two new outage periods to cover the time around
-            # the scheduled maintenance period, and remove the original.
-
-            sched_maintenances.each do |sm|
-
-              split_outs = []
-
-              outs.each { |o|
-                next unless o[:end_time] && (o[:start_time] < sm[:start_time]) &&
-                  (o[:end_time] > sm[:end_time])
-                o[:delete] = true
-                split_outs += [{:state => o[:state],
-                                :start_time => o[:start_time],
-                                :end_time => sm[:start_time],
-                                :duration => sm[:start_time] - o[:start_time],
-                                :summary => "#{o[:summary]} [split start]"},
-                               {:state => o[:state],
-                                :start_time => sm[:end_time],
-                                :end_time => o[:end_time],
-                                :duration => o[:end_time] - sm[:end_time],
-                                :summary => "#{o[:summary]} [split finish]"}]
-              }
-
-              outs.reject! {|o| o[:delete]}
-              outs += split_outs
-              # not strictly necessary to keep the data sorted, but
-              # will make more sense while debgging
-              outs.sort! {|a,b| a[:start_time] <=> b[:start_time]}
-            end
-
-            sched_maintenances.each do |sm|
-
-              outs.each do |o|
-                next unless o[:end_time] && (sm[:start_time] < o[:end_time]) &&
-                  (sm[:end_time] > o[:start_time])
-
-                if sm[:start_time] <= o[:start_time] &&
-                  sm[:end_time] >= o[:end_time]
-
-                  # outage is fully overlapped by the scheduled maintenance
-                  o[:delete] = true
-
-                elsif sm[:start_time] <= o[:start_time]
-                  # partially overlapping on the earlier side
-                  o[:start_time] = sm[:end_time]
-                  o[:duration] = o[:end_time] - o[:start_time]
-                elsif sm[:end_time] >= o[:end_time]
-                  # partially overlapping on the later side
-                  o[:end_time] = sm[:start_time]
-                  o[:duration] = o[:end_time] - o[:start_time]
-                end
-              end
-
-              outs.reject! {|o| o[:delete]}
-            end
-
-            total_secs = outs.inject(total_secs) {|ret, o|
-              ret[o[:state]] += o[:duration] if o[:duration]
-              ret
-            }
-
-            unless (start_time.nil? || end_time.nil?)
-              total_secs.each_pair do |st, ts|
-                percentages[st] = (total_secs[st] * 100.0) / (end_time.to_f - start_time.to_f)
-              end
-              total_secs['ok'] = (end_time - start_time) - total_secs.values.reduce(:+)
-              percentages['ok'] = 100 - percentages.values.reduce(:+)
-            end
-          end
-
-          {:total_seconds => total_secs, :percentages => percentages, :downtime => outs}
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/flapjack/gateways/api/entity_methods.rb

@@ -1,361 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/entity'
-require 'flapjack/data/entity_check'
-
-require 'flapjack/gateways/api/entity_presenter'
-require 'flapjack/gateways/api/entity_check_presenter'
-
-module Flapjack
-
-  module Gateways
-
-    class API < Sinatra::Base
-
-      class EntityCheckNotFound < RuntimeError
-        attr_reader :entity, :check
-        def initialize(entity, check)
-          @entity = entity
-          @check = check
-        end
-      end
-
-      class EntityNotFound < RuntimeError
-        attr_reader :entity
-        def initialize(entity)
-          @entity = entity
-        end
-      end
-
-      module EntityMethods
-
-        module Helpers
-
-          def find_entity(entity_name)
-            entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
-            raise Flapjack::Gateways::API::EntityNotFound.new(entity_name) if entity.nil?
-            entity
-          end
-
-          def find_entity_check(entity, check)
-            entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
-              check, :redis => redis)
-            raise Flapjack::Gateways::API::EntityCheckNotFound.new(entity, check) if entity_check.nil?
-            entity_check
-          end
-
-          def find_tags(tags)
-            halt err(403, "no tags") if tags.nil? || tags.empty?
-            tags
-          end
-
-          def entities_and_checks(entity_name, check)
-            if entity_name
-              # backwards-compatible, single entity or entity&check from route
-              entities = check ? nil : [entity_name]
-              checks   = check ? {entity_name => check} : nil
-            else
-              # new and improved bulk API queries
-              entities = params[:entity]
-              checks   = params[:check]
-              entities = [entities] unless entities.nil? || entities.is_a?(Array)
-              # TODO err if checks isn't a Hash (similar rules as in flapjack-diner)
-            end
-            [entities, checks]
-          end
-
-          def bulk_api_check_action(entities, entity_checks, action, params = {})
-            unless entities.nil? || entities.empty?
-              entities.each do |entity_name|
-                entity = find_entity(entity_name)
-                checks = entity.check_list.sort
-                checks.each do |check|
-                  action.call( find_entity_check(entity, check) )
-                end
-              end
-            end
-
-            unless entity_checks.nil? || entity_checks.empty?
-              entity_checks.each_pair do |entity_name, checks|
-                entity = find_entity(entity_name)
-                checks = [checks] unless checks.is_a?(Array)
-                checks.each do |check|
-                  action.call( find_entity_check(entity, check) )
-                end
-              end
-            end
-          end
-
-          def present_api_results(entities, entity_checks, result_type, &block)
-            result = []
-
-            unless entities.nil? || entities.empty?
-              result += entities.collect {|entity_name|
-                entity = find_entity(entity_name)
-                yield(Flapjack::Gateways::API::EntityPresenter.new(entity, :redis => redis))
-              }.flatten(1)
-            end
-
-            unless entity_checks.nil? || entity_checks.empty?
-              result += entity_checks.inject([]) {|memo, (entity_name, checks)|
-                checks = [checks] unless checks.is_a?(Array)
-                entity = find_entity(entity_name)
-                memo += checks.collect {|check|
-                  entity_check = find_entity_check(entity, check)
-                  {:entity => entity_name,
-                   :check => check,
-                   result_type.to_sym => yield(Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check))
-                  }
-                }
-              }.flatten(1)
-            end
-
-            result
-          end
-
-          # NB: casts to UTC before converting to a timestamp
-          def validate_and_parsetime(value)
-            return unless value
-            Time.iso8601(value).getutc.to_i
-          rescue ArgumentError => e
-            logger.error "Couldn't parse time from '#{value}'"
-            nil
-          end
-
-        end
-
-        # used for backwards-compatible route matching below
-        ENTITY_CHECK_FRAGMENT = '(?:/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(.+))?)?'
-
-        def self.registered(app)
-
-          app.helpers Flapjack::Gateways::API::EntityMethods::Helpers
-
-          app.get '/entities' do
-            content_type :json
-            ret = Flapjack::Data::Entity.all(:redis => redis).collect {|e|
-              presenter = Flapjack::Gateways::API::EntityPresenter.new(e, :redis => redis)
-              {'id' => e.id, 'name' => e.name, 'checks' => presenter.status }
-            }
-            ret.to_json
-          end
-
-          app.get '/checks/:entity' do
-            content_type :json
-            entity = find_entity(params[:entity])
-            entity.check_list.to_json
-          end
-
-          app.get %r{/status#{ENTITY_CHECK_FRAGMENT}} do
-            content_type :json
-
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            results = present_api_results(entities, checks, 'status') {|presenter|
-              presenter.status
-            }
-
-            if entity_name
-              # compatible with previous data format
-              results = results.collect {|status_h| status_h[:status]}
-              check ? results.first.to_json : "[" + results.map {|r| r.to_json }.join(',') + "]"
-            else
-              # new and improved data format which reflects the request param structure
-              "[" + results.map {|r| r.to_json }.join(',') + "]"
-            end
-          end
-
-          app.get %r{/((?:outages|(?:un)?scheduled_maintenances|downtime))#{ENTITY_CHECK_FRAGMENT}} do
-            action      = params[:captures][0].to_sym
-            entity_name = params[:captures][1]
-            check       = params[:captures][2]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            start_time = validate_and_parsetime(params[:start_time])
-            end_time   = validate_and_parsetime(params[:end_time])
-
-            results = present_api_results(entities, checks, action) {|presenter|
-              presenter.send(action, start_time, end_time)
-            }
-
-            if check
-              # compatible with previous data format
-              results.first[action].to_json
-            elsif entity_name
-              # compatible with previous data format
-              rename = {:unscheduled_maintenances => :unscheduled_maintenance,
-                        :scheduled_maintenances   => :scheduled_maintenance}
-              drop   = [:entity]
-              results.collect{|r|
-                r.inject({}) {|memo, (k, v)|
-                  if new_k = rename[k]
-                    memo[new_k] = v
-                  elsif !drop.include?(k)
-                    memo[k] = v
-                  end
-                 memo
-                }
-              }.to_json
-            else
-              # new and improved data format which reflects the request param structure
-              results.to_json
-            end
-          end
-
-          # create a scheduled maintenance period for a check on an entity
-          app.post %r{/scheduled_maintenances#{ENTITY_CHECK_FRAGMENT}} do
-
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            start_time = validate_and_parsetime(params[:start_time])
-            halt( err(403, "start time must be provided") ) unless start_time
-
-            act_proc = proc {|entity_check|
-              entity_check.create_scheduled_maintenance(start_time,
-                params[:duration].to_i, :summary => params[:summary])
-            }
-
-            bulk_api_check_action(entities, checks, act_proc)
-            status 204
-          end
-
-          # create an acknowledgement for a service on an entity
-          # NB currently, this does not acknowledge a specific failure event, just
-          # the entity-check as a whole
-          app.post %r{/acknowledgements#{ENTITY_CHECK_FRAGMENT}} do
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            dur = params[:duration] ? params[:duration].to_i : nil
-            duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
-            summary = params[:summary]
-
-            opts = {'duration' => duration}
-            opts['summary'] = summary if summary
-
-            act_proc = proc {|entity_check|
-              Flapjack::Data::Event.create_acknowledgement(
-                entity_check.entity_name, entity_check.check,
-                :summary => params[:summary],
-                :duration => duration,
-                :redis => redis)
-            }
-
-            bulk_api_check_action(entities, checks, act_proc)
-            status 204
-          end
-
-          app.delete %r{/((?:un)?scheduled_maintenances)} do
-            action = params[:captures][0]
-
-            # no backwards-compatible mode here, it's a new method
-            entities, checks = entities_and_checks(nil, nil)
-
-            act_proc = case action
-            when 'scheduled_maintenances'
-              start_time = validate_and_parsetime(params[:start_time])
-              halt( err(403, "start time must be provided") ) unless start_time
-              opts = {}
-              proc {|entity_check| entity_check.end_scheduled_maintenance(start_time.to_i) }
-            when 'unscheduled_maintenances'
-              end_time = validate_and_parsetime(params[:end_time]) || Time.now
-              proc {|entity_check| entity_check.end_unscheduled_maintenance(end_time.to_i) }
-            end
-
-            bulk_api_check_action(entities, checks, act_proc)
-            status 204
-          end
-
-          app.post %r{/test_notifications#{ENTITY_CHECK_FRAGMENT}} do
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            act_proc = proc {|entity_check|
-              summary = params[:summary] ||
-                        "Testing notifications to all contacts interested in entity #{entity_check.entity.name}"
-              Flapjack::Data::Event.test_notifications(
-                entity_check.entity_name, entity_check.check,
-                :summary => summary,
-                :redis => redis)
-            }
-
-            bulk_api_check_action(entities, checks, act_proc)
-            status 204
-          end
-
-          app.post '/entities' do
-            pass unless 'application/json'.eql?(request.content_type)
-
-            errors = []
-            ret = nil
-
-            # FIXME should scan for invalid records before making any changes, fail early
-
-            entities = params[:entities]
-            unless entities
-              logger.debug("no entities object found in the following supplied JSON:")
-              logger.debug(request.body)
-              return err(403, "No entities object received")
-            end
-            return err(403, "The received entities object is not an Enumerable") unless entities.is_a?(Enumerable)
-            return err(403, "Entity with a nil id detected") unless entities.any? {|e| !e['id'].nil?}
-
-            entities.each do |entity|
-              unless entity['id']
-                errors << "Entity not imported as it has no id: #{entity.inspect}"
-                next
-              end
-              Flapjack::Data::Entity.add(entity, :redis => redis)
-            end
-            errors.empty? ? 204 : err(403, *errors)
-          end
-
-          app.post '/entities/:entity/tags' do
-            content_type :json
-
-            tags = find_tags(params[:tag])
-            entity = find_entity(params[:entity])
-            entity.add_tags(*tags)
-            entity.tags.to_json
-          end
-
-          app.delete '/entities/:entity/tags' do
-            tags = find_tags(params[:tag])
-            entity = find_entity(params[:entity])
-            entity.delete_tags(*tags)
-            status 204
-          end
-
-          app.get '/entities/:entity/tags' do
-            content_type :json
-
-            entity = find_entity(params[:entity])
-            entity.tags.to_json
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/flapjack/gateways/api/entity_presenter.rb

@@ -1,75 +0,0 @@
-#!/usr/bin/env ruby
-
-# Formats entity data for presentation by the API methods in Flapjack::Gateways::API.
-# Currently this just aggregates all of the check data for an entity, leaving
-# clients to make any further calculations for themselves.
-
-require 'sinatra/base'
-
-require 'flapjack/gateways/api/entity_check_presenter'
-require 'flapjack/data/entity_check'
-
-module Flapjack
-
-  module Gateways
-
-    class API < Sinatra::Base
-
-      class EntityPresenter
-
-        def initialize(entity, options = {})
-          @entity = entity
-          @redis = options[:redis]
-        end
-
-        def status
-          checks.collect {|c| {:entity => @entity.name, :check => c,
-                               :status => check_presenter(c).status } }
-        end
-
-        def outages(start_time, end_time)
-          checks.collect {|c|
-            {:entity => @entity.name, :check => c, :outages => check_presenter(c).outages(start_time, end_time)}
-          }
-        end
-
-        def unscheduled_maintenances(start_time, end_time)
-          checks.collect {|c|
-            {:entity => @entity.name, :check => c, :unscheduled_maintenances =>
-              check_presenter(c).unscheduled_maintenances(start_time, end_time)}
-          }
-        end
-
-        def scheduled_maintenances(start_time, end_time)
-          checks.collect {|c|
-            {:entity => @entity.name, :check => c, :scheduled_maintenances =>
-              check_presenter(c).scheduled_maintenances(start_time, end_time)}
-          }
-        end
-
-        def downtime(start_time, end_time)
-          checks.collect {|c|
-            {:entity => @entity.name, :check => c, :downtime =>
-              check_presenter(c).downtime(start_time, end_time)}
-          }
-        end
-
-      private
-
-        def checks
-          @check_list ||= @entity.check_list.sort
-        end
-
-        def check_presenter(check)
-          entity_check = Flapjack::Data::EntityCheck.for_entity(@entity, check,
-            :redis => @redis)
-          presenter = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/flapjack/gateways/api/rack/json_params_parser.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rack'
-
-module Rack
-  class JsonParamsParser < Struct.new(:app)
-    def call(env)
-      if env['rack.input'] and not input_parsed?(env) and type_match?(env)
-        env['rack.request.form_input'] = env['rack.input']
-        data = env['rack.input'].read
-        env['rack.input'].rewind
-        env['rack.request.form_hash'] = data.empty? ? {} : Oj.load(data)
-      end
-      app.call(env)
-    end
-
-    def input_parsed? env
-      env['rack.request.form_input'].eql? env['rack.input']
-    end
-
-    def type_match? env
-      type = env['CONTENT_TYPE'] and
-        type.split(/\s*[;,]\s*/, 2).first.downcase == 'application/json'
-    end
-  end
-end