flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/gateways/jsonapi/metrics_methods.rb

@@ -1,132 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/contact'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module MetricsMethods
-
-        module Helpers
-
-          def fqdn
-            `/bin/hostname -f`.chomp
-          end
-
-          def pid
-            Process.pid
-          end
-
-          def total_keys
-            redis.dbsize
-          end
-
-          def event_queue_length
-            redis.llen('events')
-          end
-
-          def events
-            { 'processed' => processed_events,
-              'queue'     => {'length' => event_queue_length}
-            }
-          end
-
-          def processed_events
-            Hash[redis.hgetall('event_counters').map {|k,v| [k,v.to_i] }]
-          end
-
-          def processed_events_all_time
-            { 'all_time' => processed_events }
-          end
-
-          def check_freshness
-            freshnesses = [0, 60, 300, 900, 3600]
-            options     = {
-              :redis => redis,
-              :counts => true
-            }
-            Flapjack::Data::EntityCheck.find_all_split_by_freshness(freshnesses, options)
-          end
-
-          def entities
-            {
-              'all'     => Flapjack::Data::Entity.all(:redis => redis).length,
-              'enabled' => Flapjack::Data::Entity.all(:enabled => true, :redis => redis).length,
-              'failing' => Flapjack::Data::Entity.find_all_names_with_failing_checks(:redis => redis).length,
-            }
-          end
-
-          def checks
-            {
-              'all'     => Flapjack::Data::EntityCheck.count_current(:redis => redis),
-              'failing' => Flapjack::Data::EntityCheck.count_current_failing(:redis => redis),
-            }
-          end
-
-          def filter_query(query)
-            case
-            when query == 'all', query.empty?
-              'all'
-            else
-              filter = query.split(',')
-              filter.find {|q| q == 'all'} ? 'all' : filter
-            end
-          end
-        end
-
-        def self.registered(app)
-          app.helpers Flapjack::Gateways::JSONAPI::Helpers
-          app.helpers Flapjack::Gateways::JSONAPI::MetricsMethods::Helpers
-
-          app.get %r{^/metrics$} do
-
-            filter = params[:filter] ? filter_query(params[:filter]) : 'all'
-
-            keys = %w(fqdn pid total_keys processed_events_all_time event_queue_length check_freshness entities checks)
-            keys = keys.find_all {|m| filter.include?(m) } unless filter == 'all'
-
-            metrics = {}
-            keys.each do |key|
-              metrics[key] = self.send(key.to_sym)
-            end
-
-            Flapjack.dump_json(metrics)
-          end
-
-          app.get %r{^/metrics/check_freshness$} do
-            cf = self.check_freshness
-            Flapjack.dump_json({"check_freshness" => {
-              "from_0_to_60"     => cf[0],
-              "from_60_to_300"   => cf[60],
-              "from_300_to_900"  => cf[300],
-              "from_900_to_3600" => cf[900],
-              "from_3600_to_∞"   => cf[3600]
-              }})
-          end
-
-          app.get %r{^/metrics/entities$} do
-            Flapjack.dump_json({"entities" => entities})
-          end
-
-          app.get %r{^/metrics/checks$} do
-            Flapjack.dump_json({"checks" => checks})
-          end
-
-          app.get %r{^/metrics/events$} do
-            Flapjack.dump_json({"events" => events})
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/flapjack/gateways/jsonapi/notification_rule_methods.rb

@@ -1,141 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/contact'
-require 'flapjack/data/notification_rule'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module NotificationRuleMethods
-
-        # module Helpers
-        # end
-
-        def self.registered(app)
-          app.helpers Flapjack::Gateways::JSONAPI::Helpers
-          # app.helpers Flapjack::Gateways::JSONAPI::NotificationRuleMethods::Helpers
-
-          # Creates a notification rule or rules for a contact
-          app.post '/contacts/:contact_id/notification_rules' do
-            rules_data = params[:notification_rules]
-
-            if rules_data.nil? || !rules_data.is_a?(Enumerable)
-              halt err(422, "No valid notification rules were submitted")
-            end
-
-            contact = find_contact(params[:contact_id])
-
-            errors = []
-            rules_data.each do |rule_data|
-              errors << Flapjack::Data::NotificationRule.prevalidate_data(symbolize(rule_data), {:logger => logger})
-            end
-            errors.compact!
-
-            unless errors.nil? || errors.empty?
-              halt err(422, *errors)
-            end
-
-            rules = []
-            errors = []
-            rules_data.each do |rule_data|
-              rule_data = symbolize(rule_data)
-              rule_or_errors = contact.add_notification_rule(rule_data, :logger => logger)
-              if rule_or_errors.respond_to?(:critical_media)
-                rules << rule_or_errors
-              else
-                errors << rule_or_errors
-              end
-            end
-
-            if rules.empty?
-              halt err(422, *errors)
-            else
-              if errors.empty?
-                status 201
-              else
-                logger.warn("Errors during bulk notification rules creation: " + errors.join(', '))
-                halt 200
-              end
-            end
-
-            rule_ids = rules.map {|r| r.id}
-
-            unless rule_ids.empty?
-              response.headers['Location'] = "#{base_url}/notification_rules/#{rule_ids.join(',')}"
-              Flapjack.dump_json(rule_ids)
-            end
-          end
-
-          app.get %r{^/notification_rules(?:/)?([^/]+)?$} do
-            requested_notification_rules = if params[:captures] && params[:captures][0]
-              params[:captures][0].split(',').uniq
-            else
-              nil
-            end
-
-            notification_rules = if requested_notification_rules
-              Flapjack::Data::NotificationRule.find_by_ids(requested_notification_rules, :logger => logger, :redis => redis)
-            else
-              Flapjack::Data::NotificationRule.all(:redis => redis).reject {|nr| nr.id.nil? || nr.id.empty? }
-            end
-            notification_rules.compact!
-
-            if requested_notification_rules && notification_rules.empty?
-              raise Flapjack::Gateways::JSONAPI::NotificationRulesNotFound.new(requested_notification_rules)
-            end
-
-            notification_rules_json = notification_rules.collect {|notification_rule|
-              notification_rule.to_jsonapi
-            }.join(", ")
-
-            '{"notification_rules":[' + notification_rules_json + ']}'
-          end
-
-          app.patch '/notification_rules/:id' do
-            params[:id].split(',').collect {|rule_id|
-              find_rule(rule_id)
-            }.each do |rule|
-              apply_json_patch('notification_rules') do |op, property, linked, value|
-                case op
-                when 'replace'
-                  case property
-                  when 'entities', 'regex_entities', 'tags', 'regex_tags',
-                    'time_restrictions', 'unknown_media', 'warning_media',
-                    'critical_media', 'unknown_blackhole', 'warning_blackhole',
-                    'critical_blackhole'
-
-                    rule.update({property.to_sym => value}, :logger => logger)
-                  end
-                end
-              end
-            end
-
-            status 204
-          end
-
-          # Deletes one or more notification rules
-          app.delete '/notification_rules/:id' do
-            params[:id].split(',').each do |rule_id|
-              rule = find_rule(rule_id)
-              logger.debug("rule to delete: #{rule.inspect}, contact_id: #{rule.contact_id}")
-              contact = find_contact(rule.contact_id)
-              contact.delete_notification_rule(rule)
-            end
-
-            status 204
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/flapjack/gateways/jsonapi/pagerduty_credential_methods.rb

@@ -1,139 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/contact'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module PagerdutyCredentialMethods
-
-        SEMAPHORE_CONTACT_MASS_UPDATE = 'contact_mass_update'
-
-        # module Helpers
-        # end
-
-        def self.registered(app)
-          app.helpers Flapjack::Gateways::JSONAPI::Helpers
-          # app.helpers Flapjack::Gateways::JSONAPI::PagerdutyCredentialMethods::Helpers
-
-          # Creates/overwrites pagerduty credentials for a contact
-          app.post '/contacts/:contact_id/pagerduty_credentials' do
-
-            pagerduty_credentials_data = params[:pagerduty_credentials]
-
-            if pagerduty_credentials_data.nil? || !pagerduty_credentials_data.is_a?(Enumerable)
-              halt err(422, "No valid pagerduty credentials were submitted")
-            end
-
-            fields = ['service_key', 'subdomain', 'token', 'username', 'password']
-
-            pagerduty_credential = pagerduty_credentials_data.last
-
-            if pagerduty_credential.nil? || !pagerduty_credential.is_a?(Hash)
-              halt err(422, "No valid pagerduty credentials were submitted")
-            end
-
-            if (fields | pagerduty_credential.keys).size != fields.size
-              halt err(422, "Pagerduty credential data has incorrect fields")
-            end
-
-            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
-            contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
-            if contact.nil?
-              semaphore.release
-              halt err(422, "Contact id: '#{params[:contact_id]}' could not be loaded")
-            end
-
-            pagerduty_credential_data = fields.inject({}) do |memo, field|
-              memo[field] = pagerduty_credential[field]
-              memo
-            end
-
-            contact.set_pagerduty_credentials(pagerduty_credential_data)
-            semaphore.release
-
-            pagerduty_credential_data['links'] = {'contacts' => [contact.id]}
-
-            status 201
-            response.headers['Location'] = "#{base_url}/pagerduty_credentials/#{contact.id}"
-            Flapjack.dump_json([contact.id])
-          end
-
-          app.get %r{^/pagerduty_credentials(?:/)?([^/]+)?$} do
-            contacts = if params[:captures] && params[:captures][0]
-              params[:captures][0].split(',').uniq.collect {|c_id| find_contact(c_id)}
-            else
-              Flapjack::Data::Contact.all(:redis => redis)
-            end
-
-            pagerduty_credentials_data = contacts.inject([]) do |memo, contact|
-              pdc = contact.pagerduty_credentials
-
-              unless pdc.nil?
-                pd_data = pdc.clone
-                pd_data['links'] = {'contacts' => [contact.id]}
-                memo << pd_data
-              end
-
-              memo
-            end
-
-            '{"pagerduty_credentials":' + Flapjack.dump_json(pagerduty_credentials_data) + '}'
-          end
-
-          # update one or more sets of pagerduty credentials
-          app.patch '/pagerduty_credentials/:contact_id' do
-            params[:contact_id].split(',').uniq.collect {|c_id| find_contact(c_id)}.each do |contact|
-              apply_json_patch('pagerduty_credentials') do |op, property, linked, value|
-                if 'replace'.eql?(op)
-
-                  pdc = contact.pagerduty_credentials
-                  pd_data = pdc.nil? ? {} : pdc.clone
-
-                  case property
-                  when 'service_key'
-                    pd_data['service_key'] = value
-                    contact.set_pagerduty_credentials(pd_data)
-                  when 'subdomain'
-                    pd_data['subdomain'] = value
-                    contact.set_pagerduty_credentials(pd_data)
-                  when 'token'
-                    pd_data['token'] = value
-                    contact.set_pagerduty_credentials(pd_data)
-                  when 'username'
-                    pd_data['username'] = value
-                    contact.set_pagerduty_credentials(pd_data)
-                  when 'password'
-                    pd_data['password'] = value
-                    contact.set_pagerduty_credentials(pd_data)
-                  end
-                end
-              end
-            end
-
-            status 204
-          end
-
-          app.delete '/pagerduty_credentials/:contact_id' do
-            params[:contact_id].split(',').uniq.collect {|c_id|
-              find_contact(c_id)
-            }.each {|contact|
-              contact.delete_pagerduty_credentials
-            }
-            status 204
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/flapjack/gateways/jsonapi/report_methods.rb

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/entity'
-require 'flapjack/data/entity_check'
-
-require 'flapjack/gateways/jsonapi/check_presenter'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module ReportMethods
-
-        module Helpers
-
-          def load_api_data(entity_ids, event_ids, &block)
-            entities = if entity_ids.nil?
-              Flapjack::Data::Entity.all(:redis => redis)
-            elsif !entity_ids.empty?
-              entity_ids.collect {|entity_id| find_entity_by_id(entity_id) }
-            else
-              nil
-            end
-
-            checks = if event_ids.nil?
-              Flapjack::Data::EntityCheck.find_current_names(:redis => redis).
-                each_with_object([]) do |check_name, memo|
-                  en, cn = check_name.split(':', 2)
-                  halt(err(400, 'Malformed check ID')) if en.nil? || cn.nil?
-                  logger.debug("Flapjack::Gateways::JSONAPI::ReportMethods::Helpers#load_api_data entity: #{en}, check: #{cn}")
-
-                  memo << find_entity_check_by_name(en, cn)
-                end
-            elsif !event_ids.empty?
-              event_ids.each_with_object([]) do |event_id, memo|
-                en, cn = event_id.split(':', 2)
-                halt(err(400, 'Malformed check ID')) if en.nil? || cn.nil?
-                memo << find_entity_check_by_name(en, cn)
-              end
-            else
-              nil
-            end
-
-            entities_by_id             = {}
-            entity_checks_by_entity_id = {}
-
-            (entities || []).each do |entity|
-              entities_by_id[entity.id] = entity
-              entity_checks_by_entity_id[entity.id] = entity.check_list.collect {|check_name|
-                find_entity_check(entity, check_name)
-              }
-            end
-
-            (checks || []).each do |check|
-              check_entity = check.entity
-              check_entity_id = check_entity.id
-              entities_by_id[check_entity_id] ||= check_entity
-
-              entity_checks_by_entity_id[check_entity_id] ||= []
-              entity_checks_by_entity_id[check_entity_id] << check
-            end
-
-            entity_data = entities_by_id.inject([]) do |memo, (entity_id, entity)|
-              entity_name = entity.name
-              memo << {
-                'id'    => entity_id,
-                'name'  => entity_name,
-                'links' => {
-                  'checks' => entity_checks_by_entity_id[entity_id].collect {|entity_check|
-                    "#{entity_name}:#{entity_check.check}"
-                  },
-                }
-              }
-              memo
-            end
-
-            report_data = []
-            entity_check_data = []
-
-            entity_checks_by_entity_id.each_pair do |entity_id, entity_checks|
-              entity = entities_by_id[entity_id]
-              entity_checks.each do |entity_check|
-                entity_check_name = entity_check.check
-                entity_check_id = "#{entity.name}:#{entity_check.check}"
-                report_data << yield(Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)).
-                    merge('links'  => {
-                      'entity' => [entity_id],
-                      'check'  => [entity_check_id],
-                    })
-                 entity_check_data << {
-                  'id'        => entity_check_id,
-                  'name'      => entity_check_name
-                }
-              end
-            end
-
-            [report_data, entity_data, entity_check_data]
-          end
-
-        end
-
-        def self.registered(app)
-          app.helpers Flapjack::Gateways::JSONAPI::Helpers
-          app.helpers Flapjack::Gateways::JSONAPI::ReportMethods::Helpers
-
-          app.get %r{^/(status|outage|(?:un)?scheduled_maintenance|downtime)_report/(entities|checks)(?:/([^/]+))?$} do
-            entities_or_checks = params[:captures][1]
-            action = params[:captures][0]
-
-            args = []
-            unless 'status'.eql?(action)
-              args += [validate_and_parsetime(params[:start_time]),
-                       validate_and_parsetime(params[:end_time])]
-            end
-
-            report_data, entity_data, check_data = case entities_or_checks
-            when 'entities'
-              entity_ids = params[:captures][2].nil? ? nil : params[:captures][2].split(',')
-              load_api_data(entity_ids, []) {|presenter|
-                presenter.send(action, *args)
-              }
-            when 'checks'
-              entity_check_names = params[:captures][2].nil? ? nil : params[:captures][2].split(',')
-              load_api_data([], entity_check_names) {|presenter|
-                presenter.send(action, *args)
-              }
-            end
-
-            "{\"#{action}_reports\":" + Flapjack.dump_json(report_data) + "," +
-             "\"linked\":{\"entities\":" + Flapjack.dump_json(entity_data) + "," +
-                         "\"checks\":" + Flapjack.dump_json(check_data) + "}}"
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end