flapjack 0.7.35 → 0.8.0

data/flapjack.gemspec

@@ -4,9 +4,9 @@ require File.expand_path('../lib/flapjack/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = [ "Lindsay Holmwood", "Jesse Reynolds", "Ali Graham" ]
   gem.email         = "lindsay@holmwood.id.au"
-  gem.description   = "Flapjack is distributed monitoring notification system that provides a scalable method for processing streams of events from Nagios and deciding who should be notified"
+  gem.description   = "Flapjack is a distributed monitoring notification system that provides a scalable method for processing streams of events from Nagios and deciding who should be notified"
   gem.summary       = "Intelligent, scalable, distributed monitoring notification system."
-  gem.homepage      = "http://flapjack-project.com/"
+  gem.homepage      = "http://flapjack.io/"
   gem.license       = 'MIT'
 
   # see http://yehudakatz.com/2010/12/16/clarifying-the-roles-of-the-gemspec-and-gemfile/
@@ -24,7 +24,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'hiredis'
   gem.add_dependency 'em-synchrony', '~> 1.0.2'
   gem.add_dependency 'em-http-request'
-  gem.add_dependency 'redis'
+  gem.add_dependency 'redis', '~> 3.0.6'
   gem.add_dependency 'em-resque'
   gem.add_dependency 'resque', '~> 1.23.0'
   gem.add_dependency 'sinatra'
@@ -38,6 +38,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'ice_cube'
   gem.add_dependency 'tzinfo', '~> 1.0.1'
   gem.add_dependency 'tzinfo-data'
+  gem.add_dependency 'tzinfo-data'
 
   gem.add_development_dependency 'rake'
 end

data/lib/flapjack/data/contact.rb

@@ -10,13 +10,17 @@ require 'flapjack/data/notification_rule'
 require 'flapjack/data/tag'
 require 'flapjack/data/tag_set'
 
+require 'securerandom'
+
 module Flapjack
 
   module Data
 
     class Contact
 
-      attr_accessor :id, :first_name, :last_name, :email, :media, :media_intervals, :media_rollup_thresholds, :pagerduty_credentials
+      attr_accessor :id, :first_name, :last_name, :email, :media,
+        :media_intervals, :media_rollup_thresholds, :pagerduty_credentials,
+        :linked_entity_ids
 
       TAG_PREFIX = 'contact_tag'
       ALL_MEDIA  = ['email', 'sms', 'jabber', 'pagerduty']
@@ -46,6 +50,22 @@ module Flapjack
         contact
       end
 
+      def self.find_by_ids(contact_ids, options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        logger = options[:logger]
+
+        contact_ids.map do |id|
+          self.find_by_id(id, options)
+        end
+      end
+
+      def self.exists_with_id?(contact_id, options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        raise "No id value passed" unless contact_id
+
+        redis.exists("contact:#{contact_id}")
+      end
+
       def self.add(contact_data, options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         contact_id = contact_data['id']
@@ -169,6 +189,36 @@ module Flapjack
         }.values
       end
 
+      def self.entities_jsonapi(contact_ids, options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+
+        entity_data = []
+        linked_entity_ids = {}
+
+        temp_set = SecureRandom.uuid
+        redis.sadd(temp_set, contact_ids)
+
+        redis.keys('contacts_for:*').each do |k|
+          contact_ids = redis.sinter(k, temp_set)
+          next if contact_ids.empty?
+          next unless k =~ /^contacts_for:([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?::(\w+))?$/
+
+          entity_id = $1
+          check = $2
+
+          entity_data << {:id => entity_id, :name => redis.hget("entity:#{entity_id}", 'name')}
+
+          contact_ids.each do |contact_id|
+            linked_entity_ids[contact_id] ||= []
+            linked_entity_ids[contact_id] << entity_id
+          end
+        end
+
+        redis.del(temp_set)
+
+        [entity_data, linked_entity_ids]
+      end
+
       def name
         [(self.first_name || ''), (self.last_name || '')].join(" ").strip
       end
@@ -408,11 +458,17 @@ module Flapjack
       end
 
       def to_json(*args)
-        { "id"         => self.id,
-          "first_name" => self.first_name,
-          "last_name"  => self.last_name,
-          "email"      => self.email,
-          "tags"       => self.tags.to_a }.to_json
+        { "id"                      => self.id,
+          "first_name"              => self.first_name,
+          "last_name"               => self.last_name,
+          "email"                   => self.email,
+          "media"                   => self.media,
+          "media_intervals"         => self.media_intervals,
+          "media_rollup_thresholds" => self.media_rollup_thresholds,
+          "timezone"                => self.timezone.name,
+          "tags"                    => self.tags.to_a,
+          "links"                   => {:entities => @linked_entity_ids || []}
+        }.to_json
       end
 
     private
@@ -433,6 +489,12 @@ module Flapjack
         redis.hmset("contact:#{contact_id}",
                     *['first_name', 'last_name', 'email'].collect {|f| [f, contact_data[f]]})
 
+        if ( ! contact_data['tags'].nil? && contact_data['tags'].is_a?(Enumerable))
+          contact_data['tags'].each do |t|
+            Flapjack::Data::Tag.create("#{TAG_PREFIX}:#{t}", [contact_id], :redis => redis)
+          end
+        end
+
         unless contact_data['media'].nil?
           redis.del("contact_media:#{contact_id}")
           redis.del("contact_media_intervals:#{contact_id}")
@@ -452,6 +514,16 @@ module Flapjack
             end
           }
         end
+        if contact_data.key?('timezone')
+          tz = contact_data['timezone']
+          if tz.nil?
+            redis.del("contact_tz:#{contact_id}")
+          else
+            # ActiveSupport::TimeZone or String
+            redis.set("contact_tz:#{contact_id}",
+              tz.respond_to?(:name) ? tz.name : tz )
+          end
+        end
       end
 
     end

data/lib/flapjack/data/entity.rb

@@ -16,9 +16,11 @@ module Flapjack
 
       def self.all(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        redis.keys("entity_id:*").collect {|k|
+        keys = redis.keys("entity_id:*")
+        ids = redis.mget(keys)
+        keys.collect {|k|
           k =~ /^entity_id:(.+)$/; entity_name = $1
-          self.new(:name => entity_name, :id => redis.get("entity_id:#{entity_name}"), :redis => redis)
+          self.new(:name => entity_name, :id => ids.shift, :redis => redis)
         }.sort_by(&:name)
       end
 
@@ -173,6 +175,13 @@ module Flapjack
         end
       end
 
+      def as_json(*args)
+        {
+          "id"    => self.id,
+          "name"  => self.name,
+        }
+      end
+
     private
 
       # NB: initializer should not be used directly -- instead one of the finder methods

data/lib/flapjack/data/notification_rule.rb

@@ -121,11 +121,11 @@ module Flapjack
         refresh
       end
 
-      def self.add_or_update(rule_data, options = {})
-        redis = options[:redis]
-        raise "a redis connection must be supplied" unless redis
-        logger = options[:logger]
+      def self.prevalidate_data(rule_data, options = {})
+        errors = self.validate_data(preen(rule_data), options.merge(:id_not_required => true))
+      end
 
+      def self.preen(rule_data)
         # make some assumptions about the incoming data
         rule_data[:unknown_blackhole]  = rule_data[:unknown_blackhole] || false
         rule_data[:warning_blackhole]  = rule_data[:warning_blackhole] || false
@@ -133,9 +133,16 @@ module Flapjack
         if rule_data[:tags].is_a?(Array)
           rule_data[:tags] = Flapjack::Data::TagSet.new(rule_data[:tags])
         end
+        rule_data
+      end
 
-        errors = self.validate_data(rule_data, options)
+      def self.add_or_update(rule_data, options = {})
+        redis = options[:redis]
+        raise "a redis connection must be supplied" unless redis
+        logger = options[:logger]
 
+        rule_data = preen(rule_data)
+        errors = self.validate_data(rule_data, options)
         return errors unless errors.nil? || errors.empty?
 
         # whitelisting fields, rather than passing through submitted data directly
@@ -227,61 +234,62 @@ module Flapjack
       end
 
       def self.validate_data(d, options = {})
+        id_not_required = !!options[:id_not_required]
         # hash with validation => error_message
-        validations = {proc { d.has_key?(:id) } =>
-                       "id not set",
-
-                       proc { !d.has_key?(:entities) ||
-                              ( d[:entities].nil? ||
-                                d[:entities].is_a?(Array) &&
-                                d[:entities].all? {|e| e.is_a?(String)} ) } =>
-                       "entities must be a list of strings",
-
-                       proc { !d.has_key?(:tags) ||
-                              ( d[:tags].nil? ||
-                                d[:tags].is_a?(Flapjack::Data::TagSet) &&
-                                d[:tags].all? {|et| et.is_a?(String)} ) } =>
-                       "tags must be a tag_set of strings",
-
-                       proc { !d.has_key?(:time_restrictions) ||
-                              ( d[:time_restrictions].nil? ||
-                                d[:time_restrictions].all? {|tr|
-                                  !!prepare_time_restriction(symbolize(tr))
-                                } )
-                            } =>
-                       "time restrictions are invalid",
-
-                       # TODO should the media types be checked against a whitelist?
-                       proc { !d.has_key?(:unknown_media) ||
-                              ( d[:unknown_media].nil? ||
-                                d[:unknown_media].is_a?(Array) &&
-                                d[:unknown_media].all? {|et| et.is_a?(String)} ) } =>
-                       "unknown_media must be a list of strings",
-
-                       proc { !d.has_key?(:warning_media) ||
-                              ( d[:warning_media].nil? ||
-                                d[:warning_media].is_a?(Array) &&
-                                d[:warning_media].all? {|et| et.is_a?(String)} ) } =>
-                       "warning_media must be a list of strings",
-
-                       proc { !d.has_key?(:critical_media) ||
-                              ( d[:critical_media].nil? ||
-                                d[:critical_media].is_a?(Array) &&
-                                d[:critical_media].all? {|et| et.is_a?(String)} ) } =>
-                       "critical_media must be a list of strings",
-
-                       proc { !d.has_key?(:unknown_blackhole) ||
-                              [TrueClass, FalseClass].include?(d[:unknown_blackhole].class) } =>
-                       "unknown_blackhole must be true or false",
-
-                       proc { !d.has_key?(:warning_blackhole) ||
-                              [TrueClass, FalseClass].include?(d[:warning_blackhole].class) } =>
-                       "warning_blackhole must be true or false",
-
-                       proc { !d.has_key?(:critical_blackhole) ||
-                              [TrueClass, FalseClass].include?(d[:critical_blackhole].class) } =>
-                       "critical_blackhole must be true or false",
-                      }
+        validations = {}
+        validations.merge!({ proc { d.has_key?(:id) } => "id not set"}) unless id_not_required
+        validations.merge!({
+          proc { !d.has_key?(:entities) ||
+                 ( d[:entities].nil? ||
+                   d[:entities].is_a?(Array) &&
+                   d[:entities].all? {|e| e.is_a?(String)} ) } =>
+          "entities must be a list of strings",
+
+          proc { !d.has_key?(:tags) ||
+                 ( d[:tags].nil? ||
+                   d[:tags].is_a?(Flapjack::Data::TagSet) &&
+                   d[:tags].all? {|et| et.is_a?(String)} ) } =>
+          "tags must be a tag_set of strings",
+
+          proc { !d.has_key?(:time_restrictions) ||
+                 ( d[:time_restrictions].nil? ||
+                   d[:time_restrictions].all? {|tr|
+                     !!prepare_time_restriction(symbolize(tr))
+                   } )
+               } =>
+          "time restrictions are invalid",
+
+          # TODO should the media types be checked against a whitelist?
+          proc { !d.has_key?(:unknown_media) ||
+                 ( d[:unknown_media].nil? ||
+                   d[:unknown_media].is_a?(Array) &&
+                   d[:unknown_media].all? {|et| et.is_a?(String)} ) } =>
+          "unknown_media must be a list of strings",
+
+          proc { !d.has_key?(:warning_media) ||
+                 ( d[:warning_media].nil? ||
+                   d[:warning_media].is_a?(Array) &&
+                   d[:warning_media].all? {|et| et.is_a?(String)} ) } =>
+          "warning_media must be a list of strings",
+
+          proc { !d.has_key?(:critical_media) ||
+                 ( d[:critical_media].nil? ||
+                   d[:critical_media].is_a?(Array) &&
+                   d[:critical_media].all? {|et| et.is_a?(String)} ) } =>
+          "critical_media must be a list of strings",
+
+          proc { !d.has_key?(:unknown_blackhole) ||
+                 [TrueClass, FalseClass].include?(d[:unknown_blackhole].class) } =>
+          "unknown_blackhole must be true or false",
+
+          proc { !d.has_key?(:warning_blackhole) ||
+                 [TrueClass, FalseClass].include?(d[:warning_blackhole].class) } =>
+          "warning_blackhole must be true or false",
+
+          proc { !d.has_key?(:critical_blackhole) ||
+                 [TrueClass, FalseClass].include?(d[:critical_blackhole].class) } =>
+          "critical_blackhole must be true or false",
+        })
 
         errors = validations.keys.inject([]) {|ret,vk|
           ret << "Rule #{validations[vk]}" unless vk.call

data/lib/flapjack/data/semaphore.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'securerandom'
+
+module Flapjack
+  module Data
+
+    # http://redis.io/commands/set
+    class Semaphore
+
+      SEMAPHORE_KEYSPACE = 'semaphores:'
+
+      attr_reader :token, :expiry, :resource
+
+      class ResourceLocked < RuntimeError
+      end
+
+      def initialize(resource, options)
+        raise "redis connection must be passed in options" unless @redis = options[:redis]
+        @resource = resource
+        @token    = options[:token]  || SecureRandom.uuid
+        @expiry   = options[:expiry] || 30
+
+        @key = "#{SEMAPHORE_KEYSPACE}#{@resource}"
+
+        raise Flapjack::Data::Semaphore::ResourceLocked.new unless @redis.set(@key, @token, {:nx => true, :ex => @expiry})
+      end
+
+      def release
+        unlock_script = '
+         if redis.call("get",KEYS[1]) == ARGV[1]
+          then
+            return redis.call("del",KEYS[1])
+          else
+            return 0
+          end
+        '
+        @redis.eval(unlock_script, [@key], [@token])
+      end
+
+    end
+  end
+end
+

data/lib/flapjack/gateways/api.rb

@@ -27,41 +27,37 @@ module Flapjack
 
       include Flapjack::Utility
 
-      set :show_exceptions, false
+      set :dump_errors, false
 
-      rescue_exception = Proc.new { |env, exception|
-
-        error = proc {|status, exception, *msg|
-          if !msg || msg.empty?
-            trace = exception.backtrace.join("\n")
-            msg = "#{exception.class} - #{exception.message}"
-            msg_str = "#{msg}\n#{trace}"
-          else
-            msg_str = msg.join(", ")
-          end
-          logger = Flapjack::Gateways::API.instance_variable_get('@logger')
-          case
-          when status < 500
-            logger.warn "Error: #{msg_str}"
-          else
-            logger.error "Error: #{msg_str}"
-          end
-          [status, {}, {:errors => msg}.to_json]
-        }
-
-        e = env['sinatra.error']
+      rescue_error = Proc.new {|status, exception, *msg|
+        if !msg || msg.empty?
+          trace = exception.backtrace.join("\n")
+          msg = "#{exception.class} - #{exception.message}"
+          msg_str = "#{msg}\n#{trace}"
+        else
+          msg_str = msg.join(", ")
+        end
+        case
+        when status < 500
+          @logger.warn "Error: #{msg_str}"
+        else
+          @logger.error "Error: #{msg_str}"
+        end
+        [status, {}, {:errors => msg}.to_json]
+      }
 
-        case exception
+      rescue_exception = Proc.new {|env, e|
+        case e
         when Flapjack::Gateways::API::ContactNotFound
-          error.call(403, e, "could not find contact '#{e.contact_id}'")
+          rescue_error.call(403, e, "could not find contact '#{e.contact_id}'")
         when Flapjack::Gateways::API::NotificationRuleNotFound
-          error.call(403, e, "could not find notification rule '#{e.rule_id}'")
+          rescue_error.call(403, e, "could not find notification rule '#{e.rule_id}'")
         when Flapjack::Gateways::API::EntityNotFound
-          error.call(403, e, "could not find entity '#{e.entity}'")
+          rescue_error.call(403, e, "could not find entity '#{e.entity}'")
         when Flapjack::Gateways::API::EntityCheckNotFound
-          error.call(403, e, "could not find entity check '#{e.check}'")
+          rescue_error.call(403, e, "could not find entity check '#{e.check}'")
         else
-          error.call(500, exception)
+          rescue_error.call(500, e)
         end
       }
       use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception