flapjack 0.9.6 → 1.0.0rc1

data/bin/simulate-failed-check

@@ -1,151 +0,0 @@
-#!/usr/bin/env ruby
-
-unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-  $: << File.dirname(__FILE__) + '/../lib'
-end
-
-require 'optparse'
-require 'ostruct'
-require 'redis'
-require 'eventmachine'
-
-require 'json'
-
-require 'flapjack/configuration'
-require 'flapjack/data/event'
-
-def pike(message)
-  puts "piking out: #{message}"
-  exit 1
-end
-
-def send_event(event, opts)
-  redis = opts[:redis]
-  Flapjack::Data::Event.add(event, :redis => redis)
-end
-
-def fail(opts)
-  redis = Redis.new(opts[:redis_options])
-  stop_after = (opts[:minutes] * 60).to_i
-  recover = opts[:recover]
-  state = opts[:state] || 'critical'
-  event  = {
-    'entity'    => opts[:entity] || 'foo-app-01',
-    'check'     => opts[:check]  || 'HTTP',
-    'type'      => 'service'
-  }
-  failure  = event.merge('state' => state, 'summary' => 'Simulated check output (test by operator)')
-  recovery = event.merge('state' => 'ok',  'summary' => 'Simulated check output (test by operator)')
-  key = "#{event['entity']}:#{event['check']}"
-
-  puts "#{Time.now}: sending failure event (#{state}) for #{key}"
-  send_event(failure, :redis => redis)
-
-  EM.run {
-
-    EM.add_timer(stop_after) do
-      puts "#{Time.now}: stopping"
-      if recover
-        puts "#{Time.now}: sending recovery event for #{key}"
-        send_event(recovery.merge('time' => Time.now.to_i), :redis => redis)
-      end
-      EM.stop
-    end
-
-    EM.add_periodic_timer(opts[:interval]) do
-      puts "#{Time.now}: sending failure event (#{state}) for #{key}"
-      send_event(failure.merge('time' => Time.now.to_i), :redis => redis)
-    end
-
-  }
-
-end
-
-
-options = OpenStruct.new
-options.config    = Flapjack::Configuration::DEFAULT_CONFIG_PATH
-options.daemonize = nil
-
-exe = File.basename(__FILE__)
-
-optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: #{exe} COMMAND [OPTIONS]"
-
-  opts.separator  ""
-  opts.separator  "Commands"
-  opts.separator  "     fail-and-recover"
-  opts.separator  "     fail"
-  opts.separator  ""
-  opts.separator  "Options"
-
-  opts.on("-c", "--config [PATH]", String, "PATH to the config file to use") do |c|
-    options.config = c
-  end
-
-  opts.on("-n", "--environment [ENV]", String, "Environment to boot") do |e|
-    options.environment = e
-  end
-
-  opts.on("-t", "--time MINUTES", String, "MINUTES to generate failure events for (0.75)") do |t|
-    options.minutes = t.to_f
-  end
-
-  opts.on("-i", "--interval SECONDS", String, "SECONDS between events, can be decimal eg 0.1 (10)") do |i|
-    options.interval = i.to_f
-  end
-
-  opts.on("-e", "--entity ENTITY", String, "ENTITY to generate failure events for ('foo-app-01')") do |e|
-    options.entity = e
-  end
-
-  opts.on("-k", "--check CHECK", String, "CHECK to generate failure events for ('HTTP')") do |k|
-    options.check = k
-  end
-
-  opts.on("-s", "--state STATE", String, "optional STATE to generate failure events with ('CRITICAL')") do |s|
-    options.state = s
-  end
-
-end
-optparse.parse!(ARGV)
-
-unless options.interval.to_f > 0
-  options.interval = 10.0
-end
-
-unless options.minutes
-  options.minutes = 0.75
-end
-
-FLAPJACK_ENV = options.environment || ENV['FLAPJACK_ENV'] || 'production'
-
-config = Flapjack::Configuration.new
-config.load(options.config)
-config_env = config.all
-redis_options = config.for_redis
-
-if config_env.nil? || config_env.empty?
-  puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{options.config}'"
-  puts "\n#{optparse}"
-  exit 1
-end
-
-options = {:redis_options => redis_options, :minutes => options.minutes,
-           :entity => options.entity, :check => options.check, :state => options.state,
-           :interval => options.interval}
-case ARGV[0]
-when "fail-and-recover"
-  fail(options.merge(:recover => true))
-  puts " done."
-when "fail"
-  fail(options.merge(:recover => false))
-  puts " done."
-else
-  if ARGV.nil? || ARGV.empty?
-    puts "No command provided."
-  else
-    puts "Unknown command provided: '#{ARGV[0]}'"
-  end
-  puts "\n#{optparse}"
-  exit 1
-end

data/lib/flapjack/data/migration.rb

@@ -1,36 +0,0 @@
-#!/usr/bin/env ruby
-
-module Flapjack
-  module Data
-    class Migration
-
-      def self.refresh_archive_index(options = {})
-        raise "Redis connection not set" unless redis = options[:redis]
-        archive_keys = redis.keys('events_archive:*')
-        if archive_keys.empty?
-          redis.del('known_events_archive_keys')
-          return
-        end
-
-        grouped_keys = archive_keys.group_by do |ak|
-          (redis.llen(ak) > 0) ? 'add' : 'remove'
-        end
-
-        {'remove' => :srem, 'add' => :sadd}.each_pair do |k, cmd|
-          next unless grouped_keys.has_key?(k) && !grouped_keys[k].empty?
-          redis.send(cmd, 'known_events_archive_keys', grouped_keys[k])
-        end
-      end
-
-      def self.purge_expired_archive_index(options = {})
-        raise "Redis connection not set" unless redis = options[:redis]
-        return unless redis.exists('known_events_archive_keys')
-
-        redis.smembers('known_events_archive_keys').each do |ak|
-          redis.srem('known_events_archive_keys', ak) unless redis.exists(ak)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,369 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/contact'
-require 'flapjack/data/notification_rule'
-
-module Flapjack
-
-  module Gateways
-
-    class API < Sinatra::Base
-
-      class ContactNotFound < RuntimeError
-        attr_reader :contact_id
-        def initialize(contact_id)
-          @contact_id = contact_id
-        end
-      end
-
-      class NotificationRuleNotFound < RuntimeError
-        attr_reader :rule_id
-        def initialize(rule_id)
-          @rule_id = rule_id
-        end
-      end
-
-      module ContactMethods
-
-        module Helpers
-
-          def find_contact(contact_id)
-            contact = Flapjack::Data::Contact.find_by_id(contact_id, :logger => logger, :redis => redis)
-            raise Flapjack::Gateways::API::ContactNotFound.new(contact_id) if contact.nil?
-            contact
-          end
-
-          def find_rule(rule_id)
-            rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :logger => logger, :redis => redis)
-            raise Flapjack::Gateways::API::NotificationRuleNotFound.new(rule_id) if rule.nil?
-            rule
-          end
-
-          def find_tags(tags)
-            halt err(403, "no tags") if tags.nil? || tags.empty?
-            tags
-          end
-
-        end
-
-        def self.registered(app)
-
-          app.helpers Flapjack::Gateways::API::ContactMethods::Helpers
-
-          app.post '/contacts' do
-            pass unless 'application/json'.eql?(request.content_type)
-            content_type :json
-
-            errors = []
-
-            contacts_data = params[:contacts]
-            if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
-              errors << "No valid contacts were submitted"
-            else
-              # stringifying as integer string params are automatically integered,
-              # but our redis ids are strings
-              contacts_data_ids = contacts_data.reject {|c| c['id'].nil? }.
-                map {|co| co['id'].to_s }
-
-              if contacts_data_ids.empty?
-                errors << "No contacts with IDs were submitted"
-              else
-                contacts = Flapjack::Data::Contact.all(:redis => redis)
-                contacts_h = hashify(*contacts) {|c| [c.id, c] }
-                contacts_ids = contacts_h.keys
-
-                # delete contacts not found in the bulk list
-                (contacts_ids - contacts_data_ids).each do |contact_to_delete_id|
-                  contact_to_delete = contacts.detect {|c| c.id == contact_to_delete_id }
-                  contact_to_delete.delete!
-                end
-
-                # add or update contacts found in the bulk list
-                contacts_data.reject {|cd| cd['id'].nil? }.each do |contact_data|
-                  if contacts_ids.include?(contact_data['id'].to_s)
-                    contacts_h[contact_data['id'].to_s].update(contact_data)
-                  else
-                    Flapjack::Data::Contact.add(contact_data, :redis => redis)
-                  end
-                end
-              end
-            end
-            errors.empty? ? 204 : err(403, *errors)
-          end
-
-          # Returns all the contacts
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts
-          app.get '/contacts' do
-            content_type :json
-            "[" +
-              Flapjack::Data::Contact.all(:redis => redis).map do |contact|
-                contact.to_json
-              end.join(',') +
-              "]"
-          end
-
-          # Returns the core information about the specified contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts_id
-          app.get '/contacts/:contact_id' do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            contact.to_json
-          end
-
-          # Lists this contact's notification rules
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts_id_notification_rules
-          app.get '/contacts/:contact_id/notification_rules' do
-            content_type :json
-
-            "[" + find_contact(params[:contact_id]).notification_rules.map {|r| r.to_json }.join(',') + "]"
-          end
-
-          # Get the specified notification rule for this user
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts_id_notification_rules_id
-          app.get '/notification_rules/:id' do
-            content_type :json
-
-            rule = find_rule(params[:id])
-            rule.to_json
-          end
-
-          # Creates a notification rule for a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-post_contacts_id_notification_rules
-          app.post '/notification_rules' do
-            content_type :json
-
-            if params[:id]
-              halt err(403, "post cannot be used for update, do a put instead")
-            end
-
-            logger.debug("post /notification_rules data: ")
-            logger.debug(params.inspect)
-
-            contact = find_contact(params[:contact_id])
-
-            rule_data = hashify(:entities, :regex_entities, :tags, :regex_tags,
-              :unknown_media, :warning_media, :critical_media, :time_restrictions,
-              :unknown_blackhole, :warning_blackhole, :critical_blackhole) {|k| [k, params[k]]}
-
-            rule_or_errors = contact.add_notification_rule(rule_data, :logger => logger)
-
-            unless rule_or_errors.respond_to?(:critical_media)
-              halt err(403, *rule_or_errors)
-            end
-            rule_or_errors.to_json
-          end
-
-          # Updates a notification rule
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-put_notification_rules_id
-          app.put('/notification_rules/:id') do
-            content_type :json
-
-            logger.debug("put /notification_rules/#{params[:id]} data: ")
-            logger.debug(params.inspect)
-
-            rule = find_rule(params[:id])
-
-            # previous bug may have led to rule's contact_id being wiped :(
-            contact = find_contact(rule.contact_id || params[:contact_id])
-
-            rule_data = hashify(:entities, :regex_entities, :tags, :regex_tags,
-              :unknown_media, :warning_media, :critical_media, :time_restrictions,
-              :unknown_blackhole, :warning_blackhole, :critical_blackhole) {|k| [k, params[k]]}
-
-            errors = rule.update(rule_data, :logger => logger)
-
-            unless errors.nil? || errors.empty?
-              halt err(403, *errors)
-            end
-            rule.to_json
-          end
-
-          # Deletes a notification rule
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-put_notification_rules_id
-          app.delete('/notification_rules/:id') do
-            logger.debug("delete /notification_rules/#{params[:id]}")
-            rule = find_rule(params[:id])
-            logger.debug("rule to delete: #{rule.inspect}, contact_id: #{rule.contact_id}")
-            contact = find_contact(rule.contact_id)
-            contact.delete_notification_rule(rule)
-            status 204
-          end
-
-          # Returns the media of a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts_id_media
-          app.get '/contacts/:contact_id/media' do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-
-            media = contact.media
-            media_intervals = contact.media_intervals
-            media_rollup_thresholds = contact.media_rollup_thresholds
-            media_addr_int = hashify(*media.keys) {|k|
-              [k, {'address'          => media[k],
-                   'interval'         => media_intervals[k],
-                   'rollup_threshold' => media_rollup_thresholds[k] }]
-            }
-            media_addr_int.to_json
-          end
-
-          # Returns the specified media of a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts_id_media_media
-          app.get('/contacts/:contact_id/media/:id') do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            media = contact.media[params[:id]]
-            if media.nil?
-              halt err(403, "no #{params[:id]} for contact '#{params[:contact_id]}'")
-            end
-            interval = contact.media_intervals[params[:id]]
-            if interval.nil?
-              halt err(403, "no #{params[:id]} interval for contact '#{params[:contact_id]}'")
-            end
-            rollup_threshold = contact.media_rollup_thresholds[params[:id]]
-            {'address'          => media,
-             'interval'         => interval,
-             'rollup_threshold' => rollup_threshold }.to_json
-          end
-
-          # Creates or updates a media of a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-put_contacts_id_media_media
-          app.put('/contacts/:contact_id/media/:id') do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            errors = []
-
-            if 'pagerduty'.eql?(params[:id])
-              errors = [:service_key, :subdomain, :username, :password].inject([]) do |memo, pdp|
-                memo << "no #{pdp.to_s} for 'pagerduty' media" if params[pdp].nil?
-                memo
-              end
-
-              halt err(403, *errors) unless errors.empty?
-
-              contact.set_pagerduty_credentials('service_key'  => params[:service_key],
-                                                'subdomain'    => params[:subdomain],
-                                                'username'     => params[:username],
-                                                'password'     => params[:password])
-
-              contact.pagerduty_credentials.to_json
-            else
-              if params[:address].nil?
-                errors << "no address for '#{params[:id]}' media"
-              end
-
-              halt err(403, *errors) unless errors.empty?
-
-              contact.set_address_for_media(params[:id], params[:address])
-              contact.set_interval_for_media(params[:id], params[:interval])
-              contact.set_rollup_threshold_for_media(params[:id], params[:rollup_threshold])
-
-              {'address'          => contact.media[params[:id]],
-               'interval'         => contact.media_intervals[params[:id]],
-               'rollup_threshold' => contact.media_rollup_thresholds[params[:id]]}.to_json
-            end
-          end
-
-          # delete a media of a contact
-          app.delete('/contacts/:contact_id/media/:id') do
-            contact = find_contact(params[:contact_id])
-            contact.remove_media(params[:id])
-            status 204
-          end
-
-          # Returns the timezone of a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-get_contacts_id_timezone
-          app.get('/contacts/:contact_id/timezone') do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            contact.timezone.name.to_json
-          end
-
-          # Sets the timezone of a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-put_contacts_id_timezone
-          app.put('/contacts/:contact_id/timezone') do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            contact.timezone = params[:timezone]
-            contact.timezone.name.to_json
-          end
-
-          # Removes the timezone of a contact
-          # https://github.com/flapjack/flapjack/wiki/API#wiki-put_contacts_id_timezone
-          app.delete('/contacts/:contact_id/timezone') do
-            contact = find_contact(params[:contact_id])
-            contact.timezone = nil
-            status 204
-          end
-
-          app.post '/contacts/:contact_id/tags' do
-            content_type :json
-
-            tags = find_tags(params[:tag])
-            contact = find_contact(params[:contact_id])
-            contact.add_tags(*tags)
-            contact.tags.to_json
-          end
-
-          app.post '/contacts/:contact_id/entity_tags' do
-            content_type :json
-            contact = find_contact(params[:contact_id])
-            contact.entities.map {|e| e[:entity]}.each do |entity|
-              next unless tags = params[:entity][entity.name]
-              entity.add_tags(*tags)
-            end
-            contact_ent_tag = hashify(*contact.entities(:tags => true)) {|et|
-              [et[:entity].name, et[:tags]]
-            }
-            contact_ent_tag.to_json
-          end
-
-          app.delete '/contacts/:contact_id/tags' do
-            tags = find_tags(params[:tag])
-            contact = find_contact(params[:contact_id])
-            contact.delete_tags(*tags)
-            status 204
-          end
-
-          app.delete '/contacts/:contact_id/entity_tags' do
-            contact = find_contact(params[:contact_id])
-            contact.entities.map {|e| e[:entity]}.each do |entity|
-              next unless tags = params[:entity][entity.name]
-              entity.delete_tags(*tags)
-            end
-            status 204
-          end
-
-          app.get '/contacts/:contact_id/tags' do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            contact.tags.to_json
-          end
-
-          app.get '/contacts/:contact_id/entity_tags' do
-            content_type :json
-
-            contact = find_contact(params[:contact_id])
-            contact_ent_tag = hashify(*contact.entities(:tags => true)) {|et|
-              [et[:entity].name, et[:tags]]
-            }
-            contact_ent_tag.to_json
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end