flapjack 0.6.61 → 0.7.0

data/lib/flapjack/filters/delays.rb

@@ -6,6 +6,12 @@ require 'flapjack/filters/base'
 module Flapjack
   module Filters
 
+    # * If the service event’s state is a failure, and the time since the last state change
+    #   is below a threshold (e.g. 30 seconds), then don't alert
+    # * If the service event’s state is a failure, and the time since the last alert is below a
+    #   threshold (5 minutes), and the last notification state is the same as the current state, then don’t alert
+    #
+    # OLD:
     # * If the service event’s state is a failure, and the time since the ok => failure state change
     #   is below a threshold (e.g. 30 seconds), then don't alert
     # * If the service event’s state is a failure, and the time since the last alert is below a
@@ -26,28 +32,34 @@ module Flapjack
 
           if entity_check.failed?
             last_problem_alert   = entity_check.last_problem_notification
+            last_warning_alert   = entity_check.last_warning_notification
+            last_critical_alert  = entity_check.last_critical_notification
             last_change          = entity_check.last_change
             last_notification    = entity_check.last_notification
-            last_alert_type      = last_notification[:type]
+            last_alert_state     = last_notification[:type]
             last_alert_timestamp = last_notification[:timestamp]
 
-            current_failure_duration = current_time - last_change
+            current_state_duration   = current_time - last_change
             time_since_last_alert    = current_time - last_problem_alert unless last_problem_alert.nil?
             @log.debug("Filter: Delays: last_problem_alert: #{last_problem_alert.to_s}, " +
-                       "last_change: #{last_change.to_s}, " +
-                       "current_failure_duration: #{current_failure_duration}, " +
-                       "time_since_last_alert: #{time_since_last_alert.to_s}")
-            if (current_failure_duration < failure_delay)
+                       "last_change: #{last_change.inspect}, " +
+                       "current_state_duration: #{current_state_duration.inspect}, " +
+                       "time_since_last_alert: #{time_since_last_alert.inspect}, " +
+                       "last_alert_state: [#{last_alert_state.inspect}], " +
+                       "event.state: [#{event.state.inspect}], " +
+                       "last_alert_state == event.state ? #{last_alert_state.to_s == event.state}")
+            if (current_state_duration < failure_delay)
               result = true
               @log.debug("Filter: Delays: blocking because duration of current failure " +
-                         "(#{current_failure_duration}) is less than failure_delay (#{failure_delay})")
+                         "(#{current_state_duration}) is less than failure_delay (#{failure_delay})")
             elsif !last_problem_alert.nil? && (time_since_last_alert < resend_delay) &&
-              (last_alert_type !~ /recovery/i)
+              (last_alert_state.to_s == event.state)
 
               result = true
               @log.debug("Filter: Delays: blocking because time since last alert for " +
                          "current problem (#{time_since_last_alert}) is less than " +
-                         "resend_delay (#{resend_delay}) and last alert type (#{last_alert_type}) was not a recovery")
+                         "resend_delay (#{resend_delay}) and last alert state (#{last_alert_state}) " +
+                         "is equal to current event state (#{event.state})")
             else
               @log.debug("Filter: Delays: not blocking because neither of the time comparison " +
                          "conditions were met")

data/lib/flapjack/gateways/api.rb

@@ -48,22 +48,15 @@ module Flapjack
   module Gateways
 
     class API < Sinatra::Base
-
       set :show_exceptions, false
 
-      if defined?(FLAPJACK_ENV) && 'test'.eql?(FLAPJACK_ENV)
-        # expose test errors properly
-        set :raise_errors, true
-      else
-        # doesn't work with Rack::Test unless we wrap tests in EM.synchrony blocks
-        rescue_exception = Proc.new { |env, exception|
-          @logger.error exception.message
-          @logger.error exception.backtrace.join("\n")
-          [503, {}, {:errors => [exception.message]}.to_json]
-        }
+      rescue_exception = Proc.new { |env, exception|
+        @logger.error exception.message
+        @logger.error exception.backtrace.join("\n")
+        [503, {}, {:errors => [exception.message]}.to_json]
+      }
+      use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
 
-        use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
-      end
       use Rack::MethodOverride
       use Rack::JsonParamsParser
 
@@ -316,24 +309,395 @@ module Flapjack
         content_type :json
 
         errors = []
-        ret = nil
 
-        contacts = params[:contacts]
-        if contacts && contacts.is_a?(Enumerable) && contacts.any? {|c| !c['id'].nil?}
-          Flapjack::Data::Contact.delete_all(:redis => redis)
-          contacts.each do |contact|
-            unless contact['id']
-              logger.warn "Contact not imported as it has no id: #{contact.inspect}"
-              next
+        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
-            Flapjack::Data::Contact.add(contact, :redis => redis)
           end
-          ret = 200
-        else
-          ret = 403
-          errors << "No valid contacts were submitted"
         end
-        errors.empty? ? ret : [ret, {}, {:errors => [errors]}.to_json]
+        errors.empty? ? 200 : [403, {}, {:errors => [errors]}.to_json]
+      end
+
+      # Returns all the contacts
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts
+      get '/contacts' do
+        content_type :json
+        Flapjack::Data::Contact.all(:redis => redis).to_json
+      end
+
+      # Returns the core information about the specified contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id
+      get '/contacts/:contact_id' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          logger.warn "contact not found with id #{params[:contact_id]}"
+          status 404
+          return
+        end
+        contact.to_json
+      end
+
+      # Lists this contact's notification rules
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_notification_rules
+      get '/contacts/:contact_id/notification_rules' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          logger.warn "contact not found with id #{params[:contact_id]}"
+          status 404
+          return
+        end
+        contact.notification_rules.to_json
+      end
+
+      # Get the specified notification rule for this user
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_notification_rules_id
+      get '/notification_rules/:rule_id' do
+        content_type :json
+
+        rule = Flapjack::Data::NotificationRule.find_by_id(params[:rule_id], :redis => redis)
+        if rule.nil?
+          logger.warn("Unable to find a notification rule with id [#{params[:rule_id]}]")
+          status 404
+          return
+        end
+        rule.to_json
+      end
+
+      # Creates a notification rule for a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-post_contacts_id_notification_rules
+      post '/notification_rules' do
+        # # NB if parameters are correctly passed, we shouldn't mandate a request format
+        # pass unless 'application/json'.eql?(request.content_type)
+        content_type :json
+
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          logger.warn "contact not found with id #{params[:contact_id]}"
+          status 404
+          return
+        end
+        if params[:id]
+          logger.warn "post cannot be used for update, do a put instead"
+          status 403
+          return
+        end
+
+        rule_data = hashify(:entities, :entity_tags,
+          :warning_media, :critical_media, :time_restrictions,
+          :warning_blackhole, :critical_blackhole) {|k| [k, params[k]]}
+        rule = contact.add_notification_rule(rule_data)
+        rule.to_json
+      end
+
+      # Updates a notification rule
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-put_notification_rules_id
+      put('/notification_rules/:id') do
+        # # NB if parameters are correctly passed, we shouldn't mandate a request format
+        # pass unless 'application/json'.eql?(request.content_type)
+        content_type :json
+
+        ret = nil
+
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          logger.warn "contact not found with id #{params[:contact_id]}"
+          status 404
+          return
+        end
+        rule = Flapjack::Data::NotificationRule.find_by_id(params[:id], :redis => redis)
+        if rule.nil?
+          logger.warn "rule not found with id #{params[:id]}"
+          status 404
+          return
+        end
+
+        rule_data = hashify(:entities, :entity_tags,
+          :warning_media, :critical_media, :time_restrictions,
+          :warning_blackhole, :critical_blackhole) {|k| [k, params[k]]}
+        rule.update(rule_data)
+        rule.to_json
+      end
+
+      # Deletes a notification rule
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-put_notification_rules_id
+      delete('/notification_rules/:id') do
+        rule = Flapjack::Data::NotificationRule.find_by_id(params[:id], :redis => redis)
+        if rule.nil?
+          status 404
+          return
+        end
+        contact = Flapjack::Data::Contact.find_by_id(rule.contact_id, :redis => redis)
+        if contact.nil?
+          logger.warn "contact not found with id #{rule.contact_id}"
+          status 404
+          return
+        end
+        contact.delete_notification_rule(rule)
+        status 204
+      end
+
+      # Returns the media of a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_media
+      get '/contacts/:contact_id/media' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        media = contact.media
+        media_intervals = contact.media_intervals
+        media_addr_int = hashify(*media.keys) {|k|
+          [k, {'address'  => media[k],
+               'interval' => media_intervals[k] }]
+        }
+        media_addr_int.to_json
+      end
+
+      # Returns the specified media of a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_media_media
+      get('/contacts/:contact_id/media/:media_id') do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        if contact.media[params[:media_id]].nil?
+          status 404
+          return
+        end
+        { 'address'  => contact.media[params[:media_id]],
+          'interval' => contact.media_intervals[params[:media_id]] }.to_json
+      end
+
+      # Creates or updates a media of a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-put_contacts_id_media_media
+      put('/contacts/:contact_id/media/:media_id') do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        if params[:address].nil? || params[:interval].nil?
+          status 403
+          return
+        end
+        contact.set_address_for_media(params[:media_id], params[:address])
+        contact.set_interval_for_media(params[:media_id], params[:interval])
+
+        { 'address'  => contact.media[params[:media_id]],
+          'interval' => contact.media_intervals[params[:media_id]] }.to_json
+      end
+
+      # delete a media of a contact
+      delete('/contacts/:contact_id/media/:media_id') do
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact.remove_media(params[:media_id])
+        status 204
+      end
+
+      # Returns the timezone of a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_timezone
+      get('/contacts/:contact_id/timezone') do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact.timezone.name.to_json
+      end
+
+      # Sets the timezone of a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-put_contacts_id_timezone
+      put('/contacts/:contact_id/timezone') do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact.timezone = params[:timezone]
+        contact.timezone.name.to_json
+      end
+
+      # Removes the timezone of a contact
+      # https://github.com/flpjck/flapjack/wiki/API#wiki-put_contacts_id_timezone
+      delete('/contacts/:contact_id/timezone') do
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact.timezone = nil
+        status 204
+      end
+
+      post '/contacts/:contact_id/tags' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        tags = params[:tag]
+        if tags.nil? || tags.empty?
+          status 403
+          return
+        end
+        tags = [tags] unless tags.respond_to?(:each)
+        contact.add_tags(*tags)
+        contact.tags.to_json
+      end
+
+      post '/contacts/:contact_id/entity_tags' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        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
+
+      delete '/contacts/:contact_id/tags' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        tags = params[:tag]
+        if tags.nil? || tags.empty?
+          status 403
+          return
+        end
+        tags = [tags] unless tags.respond_to?(:each)
+        contact.delete_tags(*tags)
+        status 204
+      end
+
+      delete '/contacts/:contact_id/entity_tags' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact.entities.map {|e| e[:entity]}.each do |entity|
+          next unless tags = params[:entity][entity.name]
+          entity.delete_tags(*tags)
+        end
+        status 204
+      end
+
+      get '/contacts/:contact_id/tags' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact.tags.to_json
+      end
+
+      get '/contacts/:contact_id/entity_tags' do
+        content_type :json
+        contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+        if contact.nil?
+          status 404
+          return
+        end
+        contact_ent_tag = hashify(*contact.entities(:tags => true)) {|et|
+          [et[:entity].name, et[:tags]]
+        }
+        contact_ent_tag.to_json
+      end
+
+      post '/entities/:entity/tags' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+        tags = params[:tag]
+        if tags.nil? || tags.empty?
+          status 403
+          return
+        end
+        tags = [tags] unless tags.respond_to?(:each)
+        entity.add_tags(*tags)
+        entity.tags.to_json
+      end
+
+      delete '/entities/:entity/tags' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+        tags = params[:tag]
+        if tags.nil? || tags.empty?
+          status 403
+          return
+        end
+        tags = [tags] unless tags.respond_to?(:each)
+        entity.delete_tags(*tags)
+        status 204
+      end
+
+      get '/entities/:entity/tags' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+        entity.tags.to_json
       end
 
       not_found do
@@ -366,6 +730,22 @@ module Flapjack
         nil
       end
 
+      # The passed block will be provided each value from the args
+      # and must return array pairs [key, value] representing members of
+      # the hash this method returns. Keys should be unique -- if they're
+      # not, the earlier pair for that key will be overwritten.
+      def hashify(*args, &block)
+        key_value_pairs = args.map {|a| yield(a) }
+
+        # if using Ruby 1.9,
+        #   Hash[ key_value_pairs ]
+        # is all that's needed, but for Ruby 1.8 compatability, these must
+        # be flattened and the resulting array unpacked. flatten(1) only
+        # flattens the arrays constructed in the block, it won't mess up
+        # any values (or keys) that are themselves arrays.
+        Hash[ *( key_value_pairs.flatten(1) )]
+      end
+
     end
 
   end