flapjack 0.8.10 → 0.8.11

data/lib/flapjack/gateways/jsonapi/{entity_check_presenter.rb → check_presenter.rb}

@@ -12,7 +12,7 @@ module Flapjack
 
     class JSONAPI < Sinatra::Base
 
-      class EntityCheckPresenter
+      class CheckPresenter
 
         def initialize(entity_check)
           @entity_check = entity_check
@@ -24,6 +24,7 @@ module Flapjack
            '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,
@@ -32,7 +33,7 @@ module Flapjack
            'last_acknowledgement_notification' => @entity_check.last_notification_for_state(:acknowledgement)[:timestamp]}
         end
 
-        def outages(start_time, end_time, options = {})
+        def outage(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?
@@ -83,7 +84,7 @@ module Flapjack
           result
         end
 
-        def unscheduled_maintenances(start_time, end_time)
+        def unscheduled_maintenance(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)
@@ -98,7 +99,7 @@ module Flapjack
           start_in_unsched + unsched_maintenance
         end
 
-        def scheduled_maintenances(start_time, end_time)
+        def scheduled_maintenance(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)
@@ -119,9 +120,9 @@ module Flapjack
         #
         # TODO test performance with larger data sets
         def downtime(start_time, end_time)
-          sched_maintenances = scheduled_maintenances(start_time, end_time)
+          sched_maintenances = scheduled_maintenance(start_time, end_time)
 
-          outs = outages(start_time, end_time)
+          outs = outage(start_time, end_time)
 
           total_secs  = {}
           percentages = {}

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

@@ -18,28 +18,11 @@ module Flapjack
 
         module Helpers
 
-          def find_contact(contact_id)
-            contact = Flapjack::Data::Contact.find_by_id(contact_id, :logger => logger, :redis => redis)
-            raise Flapjack::Gateways::JSONAPI::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::JSONAPI::NotificationRuleNotFound.new(rule_id) if rule.nil?
-            rule
-          end
-
-          def find_tags(tags)
-            halt err(400, "no tags given") if tags.nil? || tags.empty?
-            tags
-          end
-
           def obtain_semaphore(resource)
             semaphore = nil
             strikes = 0
             begin
-              semaphore = Flapjack::Data::Semaphore.new(resource, {:redis => redis, :expiry => 30})
+              semaphore = Flapjack::Data::Semaphore.new(resource, :redis => redis, :expiry => 30)
             rescue Flapjack::Data::Semaphore::ResourceLocked
               strikes += 1
               raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) unless strikes < 3
@@ -50,50 +33,32 @@ module Flapjack
             semaphore
           end
 
-          def apply_json_patch(object_path, &block)
-            ops = params[:ops]
+          def bulk_contact_operation(contact_ids, &block)
+            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
 
-            if ops.nil? || !ops.is_a?(Array)
-              halt err(400, "Invalid JSON-Patch request")
+            contacts_by_id = contact_ids.inject({}) do |memo, contact_id|
+              # can't use find_contact here as that would halt immediately
+              memo[contact_id] = Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis, :logger => logger)
+              memo
             end
 
-            ops.each do |operation|
-              linked = nil
-              property = nil
-
-              op = operation['op']
-              operation['path'] =~ /\A\/#{object_path}\/0\/([^\/]+)(?:\/([^\/]+)(?:\/([^\/]+))?)?\z/
-              if 'links'.eql?($1)
-                linked = $2
-
-                value = case op
-                when 'add'
-                  operation['value']
-                when 'remove'
-                  $3
-                end
-              elsif 'replace'.eql?(op)
-                property = $1
-                value = $3
-              else
-                next
-              end
-
-              yield(op, property, linked, value)
+            missing_ids = contacts_by_id.select {|k, v| v.nil? }.keys
+            unless missing_ids.empty?
+              semaphore.release
+              halt(404, "Contacts with ids #{missing_ids.join(', ')} were not found")
             end
+
+            block.call(contacts_by_id.select {|k, v| !v.nil? }.values)
+            semaphore.release
           end
 
         end
 
         def self.registered(app)
-
+          app.helpers Flapjack::Gateways::JSONAPI::Helpers
           app.helpers Flapjack::Gateways::JSONAPI::ContactMethods::Helpers
 
           app.post '/contacts' do
-            pass unless is_json_request?
-            content_type :json
-            cors_headers
-
             contacts_data = params[:contacts]
 
             if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
@@ -126,23 +91,20 @@ module Flapjack
 
             ids = contacts_data.map {|c| c['id']}
             location(ids)
+            status 201
 
             contacts_data.map {|cd| cd['id']}.to_json
           end
 
-          # Returns all (/contacts) or some (/contacts/1,2,3) or one (/contact/2) contact(s)
+          # Returns all (/contacts) or some (/contacts/1,2,3) or one (/contacts/2) contact(s)
           # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts
-          app.get %r{/contacts(?:/)?([^/]+)?$} do
-            content_type 'application/vnd.api+json'
-            cors_headers
-
+          app.get %r{^/contacts(?:/)?([^/]+)?$} do
             requested_contacts = if params[:captures] && params[:captures][0]
               params[:captures][0].split(',').uniq
             else
               nil
             end
 
-            #FIXME: do we need to url decode the ids? has rack or some middleware already done this?
             contacts = if requested_contacts
               Flapjack::Data::Contact.find_by_ids(requested_contacts, :logger => logger, :redis => redis)
             else
@@ -154,315 +116,62 @@ module Flapjack
               raise Flapjack::Gateways::JSONAPI::ContactsNotFound.new(requested_contacts)
             end
 
-            linked_entity_data, linked_entity_ids = if contacts.empty?
-              [[], []]
-            else
-              Flapjack::Data::Contact.entities_jsonapi(contacts.map(&:id), :redis => redis)
-            end
-
-            linked_media_data = []
-            linked_media_ids  = {}
-            contacts.each do |contact|
-              contact.media.keys.each do |medium|
-                id = "#{contact.id}_#{medium}"
-                interval = contact.media_intervals[medium].nil? ? nil : contact.media_intervals[medium].to_i
-                rollup_threshold = contact.media_rollup_thresholds[medium].nil? ? nil : contact.media_rollup_thresholds[medium].to_i
-                linked_media_ids[contact.id] = id
-                linked_media_data <<
-                  { "id" => id,
-                    "type" => medium,
-                    "address" => contact.media[medium],
-                    "interval" => interval,
-                    "rollup_threshold" => rollup_threshold,
-                    "contact_id" => contact.id }
-              end
-            end
+            entity_ids = Flapjack::Data::Contact.entity_ids_for(contacts.map(&:id), :redis => redis)
 
             contacts_json = contacts.collect {|contact|
-              contact.linked_entity_ids = linked_entity_ids[contact.id]
-              contact.linked_media_ids  = linked_media_ids[contact.id]
-              contact.to_jsonapi
+              contact.to_jsonapi(:entity_ids => entity_ids[contact.id])
             }.join(", ")
 
-            '{"contacts":[' + contacts_json + ']' +
-                ',"linked":{"entities":' + linked_entity_data.to_json +
-                          ',"media":' + linked_media_data.to_json + '}}'
-          end
-
-          # Returns the core information about the specified contact
-          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id
-          app.get '/contacts/:contact_id' do
-            content_type 'application/vnd.api+json'
-            cors_headers
-            contact = find_contact(params[:contact_id])
-
-            entities = contact.entities.map {|e| e[:entity] }
-
-            '{"contacts":[' + contact.to_jsonapi + ']' +
-              ( entities.empty? ? '}' :
-                ', "linked": {"entities":' + entities.values.to_json + '}}')
-          end
-
-          # Updates a contact
-          app.put '/contacts/:contact_id' do
-            cors_headers
-            content_type :json
-
-            contacts_data = params[:contacts]
-
-            if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
-              halt err(422, "No valid contacts were submitted")
-            end
-
-            unless contacts_data.length == 1
-              halt err(422, "Exactly one contact hash must be supplied.")
-            end
-
-            contact_data = contacts_data.first
-
-            if contact_data['id'] && contact_data['id'].to_s != params[:contact_id]
-              halt err(422, "ID, if supplied, must match URL")
-            end
-
-            contact = find_contact(params[:contact_id])
-            #contact_data = hashify('first_name', 'last_name', 'email', 'media', 'tags') {|k| [k, params[k]]}
-            logger.debug("contact_data: #{contact_data}")
-            contact.update(contact_data)
-
-            contact.to_jsonapi
-          end
-
-          # TODO this should build up all data, verify entities exist, etc.
-          # before applying any changes
-          # TODO generalise JSON-Patch data parsing code
-          app.patch '/contacts/:contact_id' do
-            pass unless is_jsonpatch_request?
-            content_type :json
-            cors_headers
-
-            contact = find_contact(params[:contact_id])
-
-            apply_json_patch('contacts') do |op, property, linked, value|
-              case op
-              when 'replace'
-                if ['first_name', 'last_name', 'email'].include?(property)
-                  contact.update(property => value)
-                end
-              when 'add'
-                logger.debug "patch add operation. linked: #{linked}"
-                if 'entities'.eql?(linked)
-                  entity = Flapjack::Data::Entity.find_by_id(value, :redis => redis)
-                  logger.debug "adding this entity: #{entity}"
-                  contact.add_entity(entity) unless entity.nil?
-                end
-              when 'remove'
-                if 'entities'.eql?(linked)
-                  entity = Flapjack::Data::Entity.find_by_id(value, :redis => redis)
-                  contact.remove_entity(entity) unless entity.nil?
+            '{"contacts":[' + contacts_json + ']}'
+          end
+
+          app.patch '/contacts/:id' do
+            bulk_contact_operation(params[:id].split(',')) do |contacts|
+              contacts.each do |contact|
+                apply_json_patch('contacts') do |op, property, linked, value|
+                  case op
+                  when 'replace'
+                    if ['first_name', 'last_name', 'email'].include?(property)
+                      contact.update(property => value)
+                    end
+                  when 'add'
+                    case linked
+                    when 'entities'
+                      entity = Flapjack::Data::Entity.find_by_id(value, :redis => redis)
+                      contact.add_entity(entity) unless entity.nil?
+                    when 'notification_rules'
+                      notification_rule = Flapjack::Data::NotificationRule.find_by_id(value, :redis => redis)
+                      unless notification_rule.nil?
+                        contact.grab_notification_rule(notification_rule)
+                      end
+                    # when 'media' # not supported yet due to id brokenness
+                    end
+                  when 'remove'
+                    case linked
+                    when 'entities'
+                      entity = Flapjack::Data::Entity.find_by_id(value, :redis => redis)
+                      contact.remove_entity(entity) unless entity.nil?
+                    when 'notification_rules'
+                      notification_rule = Flapjack::Data::NotificationRule.find_by_id(value, :redis => redis)
+                      unless notification_rule.nil?
+                        contact.delete_notification_rule(notification_rule)
+                      end
+                    # when 'media' # not supported yet due to id brokenness
+                    end
+                  end
                 end
               end
             end
 
-            # will need to be 200 and return contact.to_jsonapi
-            # if updated_at changes, or Etag, when those are introduced
-            status 204
-          end
-
-          # Deletes a contact
-          app.delete '/contacts/:contact_id' do
-            cors_headers
-            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
-            contact = find_contact(params[:contact_id])
-            contact.delete!
-            semaphore.release
             status 204
           end
 
-          app.post '/media' do
-            pass unless is_json_request?
-            content_type :json
-            cors_headers
-
-            media_data = params[:media]
-
-            if media_data.nil? || !media_data.is_a?(Enumerable)
-              halt err(422, "No valid media were submitted")
-            end
-
-            unless media_data.all? {|m| m['id'].nil? }
-              halt err(422, "Media creation cannot include IDs")
+          # Delete one or more contacts
+          app.delete '/contacts/:id' do
+            bulk_contact_operation(params[:id].split(',')) do |contacts|
+              contacts.each {|contact| contact.delete!}
             end
 
-            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
-
-            contacts = media_data.inject({}) {|memo, medium_data|
-              contact_id = medium_data['contact_id']
-              if contact_id.nil?
-                semaphore.release
-                halt err(422, "Media data must include 'contact_id'")
-              end
-              next memo if memo.has_key?(contact_id)
-              contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis)
-              if contact.nil?
-                semaphore.release
-                halt err(422, "Contact id:'#{contact_id}' could not be loaded")
-              end
-              memo[contact_id] = contact
-              memo
-            }
-
-            media_data.each do |medium_data|
-              contact = contacts[medium_data['contact_id']]
-              type = medium_data['type']
-              contact.set_address_for_media(type, medium_data['address'])
-              contact.set_interval_for_media(type, medium_data['interval'])
-              contact.set_rollup_threshold_for_media(type, medium_data['rollup_threshold'])
-              medium_data['id'] = "#{contact.id}_#{type}"
-            end
-
-            semaphore.release
-
-            '{"media":' + media_data.to_json + '}'
-          end
-
-          app.patch '/media/:media_id' do
-            pass unless is_jsonpatch_request?
-            content_type :json
-            cors_headers
-
-            media_id = params[:media_id]
-            media_id =~ /\A(.+)_(email|sms|jabber)\z/
-
-            contact_id = $1
-            type = $2
-
-            halt err(422, "Could not get contact_id from media_id") if contact_id.nil?
-            halt err(422, "Could not get type from media_id") if type.nil?
-
-            contact = find_contact(contact_id)
-
-            apply_json_patch('media') do |op, property, linked, value|
-              if 'replace'.eql?(op)
-                case property
-                when 'address'
-                  contact.set_address_for_media(type, value)
-                when 'interval'
-                  contact.set_interval_for_media(type, value)
-                when 'rollup_threshold'
-                  contact.set_rollup_threshold_for_media(type, value)
-                end
-              end
-            end
-
-            status 204
-          end
-
-          app.get '/notification_rules/:id' do
-            content_type :json
-            cors_headers
-
-            '{"notification_rules":[' +
-              find_rule(params[:id]).to_json +
-              ']}'
-          end
-
-          # Creates a notification rule or rules for a contact
-          app.post '/notification_rules' do
-            content_type :json
-            cors_headers
-
-            rules_data = params[:notification_rules]
-
-            if rules_data.nil? || !rules_data.is_a?(Enumerable)
-              halt err(422, "No valid notification rules were submitted")
-            end
-
-            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)
-              contact   = find_contact(rule_data.delete(:contact_id))
-              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(', '))
-                status 200
-              end
-            end
-            ids = rules.map {|r| r.id}
-            location(ids)
-            '{"notification_rules":[' +
-              rules.map {|r| r.to_json}.join(',') +
-              ']}'
-          end
-
-          # Updates a notification rule
-          app.put('/notification_rules/:id') do
-            content_type :json
-            cors_headers
-
-            rules_data = params[:notification_rules]
-
-            if rules_data.nil? || !rules_data.is_a?(Enumerable)
-              halt err(422, "No valid notification rules were submitted")
-            end
-
-            unless rules_data.length == 1
-              halt err(422, "Exactly one notification rules hash must be supplied.")
-            end
-
-            rule_data = rules_data.first
-
-            if rule_data['id'] && rule_data['id'].to_s != params[:id]
-              halt err(422, "ID, if supplied, must match URL")
-            end
-
-            rule = find_rule(params[:id])
-            contact = find_contact(rule.contact_id)
-
-            supplied_contact = rule_data.delete('contact_id')
-            if supplied_contact && supplied_contact != contact.id
-              halt err(422, "contact_id cannot be modified")
-            end
-
-            errors = rule.update(symbolize(rule_data), :logger => logger)
-
-            unless errors.nil? || errors.empty?
-              halt err(422, *errors)
-            end
-            '{"notification_rules":[' +
-              rule.to_json +
-              ']}'
-          end
-
-          # Deletes a notification rule
-          app.delete('/notification_rules/:id') do
-            cors_headers
-            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