flapjack 0.8.10 → 0.8.11

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

@@ -5,9 +5,6 @@ require 'sinatra/base'
 require 'flapjack/data/entity'
 require 'flapjack/data/entity_check'
 
-require 'flapjack/gateways/jsonapi/entity_presenter'
-require 'flapjack/gateways/jsonapi/entity_check_presenter'
-
 module Flapjack
 
   module Gateways
@@ -18,297 +15,169 @@ module Flapjack
 
         module Helpers
 
-          def find_entity(entity_name)
-            entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
-            raise Flapjack::Gateways::JSONAPI::EntityNotFound.new(entity_name) if entity.nil?
-            entity
-          end
-
-          def find_entity_check(entity, check)
-            entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
-              check, :redis => redis)
-            raise Flapjack::Gateways::JSONAPI::EntityCheckNotFound.new(entity, check) if entity_check.nil?
-            entity_check
-          end
-
-          def find_tags(tags)
-            halt err(403, "no tags") if tags.nil? || tags.empty?
-            tags
-          end
-
-          def entities_and_checks(entity_name, check)
-            if entity_name
-              # backwards-compatible, single entity or entity&check from route
-              entities = check ? nil : [entity_name]
-              checks   = check ? {entity_name => check} : nil
-            else
-              # new and improved bulk API queries
-              entities = params[:entity]
-              checks   = params[:check]
-              entities = [entities] unless entities.nil? || entities.is_a?(Array)
-              # TODO err if checks isn't a Hash (similar rules as in flapjack-diner)
-            end
-            [entities, checks]
-          end
-
-          def bulk_api_check_action(entities, entity_checks, action, params = {})
-            unless entities.nil? || entities.empty?
-              entities.each do |entity_name|
-                entity = find_entity(entity_name)
-                checks = entity.check_list.sort
-                checks.each do |check|
-                  action.call( find_entity_check(entity, check) )
-                end
-              end
-            end
-
-            unless entity_checks.nil? || entity_checks.empty?
-              entity_checks.each_pair do |entity_name, checks|
-                entity = find_entity(entity_name)
-                checks = [checks] unless checks.is_a?(Array)
-                checks.each do |check|
-                  action.call( find_entity_check(entity, check) )
-                end
+          def checks_for_entity_ids(entity_ids)
+            return if entity_ids.nil?
+            entity_ids.inject([]) do |memo, entity_id|
+              entity = find_entity_by_id(entity_id)
+              check_names = entity.check_list.sort
+              check_names.each do |check_name|
+                memo << find_entity_check(entity, check_name)
               end
+              memo
             end
           end
+        end
 
-          def present_api_results(entities, entity_checks, result_type, &block)
-            result = []
+        def self.registered(app)
+          app.helpers Flapjack::Gateways::JSONAPI::Helpers
+          app.helpers Flapjack::Gateways::JSONAPI::EntityMethods::Helpers
 
-            unless entities.nil? || entities.empty?
-              result += entities.collect {|entity_name|
-                entity = find_entity(entity_name)
-                yield(Flapjack::Gateways::JSONAPI::EntityPresenter.new(entity, :redis => redis))
-              }.flatten(1)
+          # Returns all (/entities) or some (/entities/A,B,C) or one (/entities/A) contact(s)
+          # NB: only works with good data -- i.e. entity must have an id
+          app.get %r{^/entities(?:/)?([^/]+)?$} do
+            requested_entities = if params[:captures] && params[:captures][0]
+              params[:captures][0].split(',').uniq
+            else
+              nil
             end
 
-            unless entity_checks.nil? || entity_checks.empty?
-              result += entity_checks.inject([]) {|memo, (entity_name, checks)|
-                checks = [checks] unless checks.is_a?(Array)
-                entity = find_entity(entity_name)
-                memo += checks.collect {|check|
-                  entity_check = find_entity_check(entity, check)
-                  {:entity => entity_name,
-                   :check => check,
-                   result_type.to_sym => yield(Flapjack::Gateways::JSONAPI::EntityCheckPresenter.new(entity_check))
-                  }
-                }
-              }.flatten(1)
+            entities = if requested_entities
+              Flapjack::Data::Entity.find_by_ids(requested_entities, :logger => logger, :redis => redis)
+            else
+              Flapjack::Data::Entity.all(:redis => redis)
             end
+            entities.compact!
 
-            result
-          end
-
-          # NB: casts to UTC before converting to a timestamp
-          def validate_and_parsetime(value)
-            return unless value
-            Time.iso8601(value).getutc.to_i
-          rescue ArgumentError => e
-            logger.error "Couldn't parse time from '#{value}'"
-            nil
-          end
-
-        end
-
-        # used for backwards-compatible route matching below
-        ENTITY_CHECK_FRAGMENT = '(?:/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(.+))?)?'
-
-        def self.registered(app)
-
-          app.helpers Flapjack::Gateways::JSONAPI::EntityMethods::Helpers
+            if requested_entities && requested_entities.empty?
+              raise Flapjack::Gateways::JSONAPI::EntitiesNotFound.new(requested_entities)
+            end
 
-          app.get '/entities' do
-            content_type :json
-            cors_headers
+            linked_contact_ids = Flapjack::Data::Entity.contact_ids_for(entities.map(&:id), :redis => redis)
 
-            entities_json = Flapjack::Data::Entity.all(:redis => redis).collect {|e|
-              presenter = Flapjack::Gateways::JSONAPI::EntityPresenter.new(e, :redis => redis)
-              id = (e.id.respond_to?(:length) && e.id.length > 0) ? e.id : e.name
-              {'id' => id, 'name' => e.name, 'checks' => presenter.status }.to_json
-            }.join(',')
+            entities_json = entities.collect {|entity|
+              entity.to_jsonapi(:contact_ids => linked_contact_ids[entity.id])
+            }.join(",")
 
             '{"entities":[' + entities_json + ']}'
           end
 
+          app.post '/entities' do
+            entities = wrapped_params('entities')
+            return err(403, "Entity with a nil id detected") if entities.any? {|e| e['id'].nil?}
 
-          app.get %r{/status#{ENTITY_CHECK_FRAGMENT}} do
-            content_type :json
-
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            results = present_api_results(entities, checks, 'status') {|presenter|
-              presenter.status
+            entity_ids = entities.collect{|entity_data|
+              Flapjack::Data::Entity.add(entity_data, :redis => redis)
+              entity_data['id']
             }
 
-            if entity_name
-              # compatible with previous data format
-              results = results.collect {|status_h| status_h[:status]}
-              check ? results.first.to_json : "[" + results.map {|r| r.to_json }.join(',') + "]"
-            else
-              # new and improved data format which reflects the request param structure
-              "[" + results.map {|r| r.to_json }.join(',') + "]"
-            end
+            response.headers['Location'] = "#{request.base_url}/entities/#{entity_ids.join(',')}"
+            status 201
+            entity_ids.to_json
           end
 
-          app.get %r{/((?:outages|(?:un)?scheduled_maintenances|downtime))#{ENTITY_CHECK_FRAGMENT}} do
-            action      = params[:captures][0].to_sym
-            entity_name = params[:captures][1]
-            check       = params[:captures][2]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            start_time = validate_and_parsetime(params[:start_time])
-            end_time   = validate_and_parsetime(params[:end_time])
-
-            results = present_api_results(entities, checks, action) {|presenter|
-              presenter.send(action, start_time, end_time)
-            }
-
-            if check
-              # compatible with previous data format
-              results.first[action].to_json
-            elsif entity_name
-              # compatible with previous data format
-              rename = {:unscheduled_maintenances => :unscheduled_maintenance,
-                        :scheduled_maintenances   => :scheduled_maintenance}
-              drop   = [:entity]
-              results.collect{|r|
-                r.inject({}) {|memo, (k, v)|
-                  if new_k = rename[k]
-                    memo[new_k] = v
-                  elsif !drop.include?(k)
-                    memo[k] = v
+          app.patch '/entities/:id' do
+            params[:id].split(',').collect {|entity_id|
+              find_entity_by_id(entity_id)
+            }.each do |entity|
+              apply_json_patch('entities') do |op, property, linked, value|
+                case op
+                when 'replace'
+                  if ['name'].include?(property)
+                    # # Name change not supported in Flapjack v1.x, too many changes required
+                    # entity.update(property => value)
                   end
-                 memo
-                }
-              }.to_json
-            else
-              # new and improved data format which reflects the request param structure
-              results.to_json
+                when 'add'
+                  if 'contacts'.eql?(linked)
+                    contact = Flapjack::Data::Contact.find_by_id(value, :redis => redis)
+                    contact.add_entity(entity) unless contact.nil?
+                  end
+                when 'remove'
+                  if 'contacts'.eql?(linked)
+                    contact = Flapjack::Data::Contact.find_by_id(value, :redis => redis)
+                    contact.remove_entity(entity) unless contact.nil?
+                  end
+                end
+              end
             end
+
+            status 204
           end
 
           # create a scheduled maintenance period for a check on an entity
-          app.post %r{/scheduled_maintenances#{ENTITY_CHECK_FRAGMENT}} do
-
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            start_time = validate_and_parsetime(params[:start_time])
-            halt( err(403, "start time must be provided") ) unless start_time
-
-            act_proc = proc {|entity_check|
-              entity_check.create_scheduled_maintenance(start_time,
-                params[:duration].to_i, :summary => params[:summary])
-            }
+          app.post %r{^/scheduled_maintenances/entities/([^/]+)$} do
+            scheduled_maintenances = wrapped_params('scheduled_maintenances')
+            checks_for_entity_ids(params[:captures][0].split(',')).each do |check|
+              scheduled_maintenances.each do |wp|
+                start_time = validate_and_parsetime(wp['start_time'])
+                halt( err(403, "start time must be provided") ) unless start_time
+                check.create_scheduled_maintenance(start_time,
+                  wp['duration'].to_i, :summary => wp['summary'])
+              end
+            end
 
-            bulk_api_check_action(entities, checks, act_proc)
             status 204
           end
 
           # create an acknowledgement for a service on an entity
           # NB currently, this does not acknowledge a specific failure event, just
           # the entity-check as a whole
-          app.post %r{/acknowledgements#{ENTITY_CHECK_FRAGMENT}} do
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            dur = params[:duration] ? params[:duration].to_i : nil
-            duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
-            summary = params[:summary]
-
-            opts = {'duration' => duration}
-            opts['summary'] = summary if summary
-
-            act_proc = proc {|entity_check|
-              Flapjack::Data::Event.create_acknowledgement(
-                entity_check.entity_name, entity_check.check,
-                :summary => params[:summary],
-                :duration => duration,
-                :redis => redis)
-            }
+          app.post %r{^/unscheduled_maintenances/entities/([^/]+)$} do
+            unscheduled_maintenances = wrapped_params('unscheduled_maintenances', false)
+            checks_for_entity_ids(params[:captures][0].split(',')).each do |check|
+              unscheduled_maintenances.each do |wp|
+                dur = wp['duration'] ? wp['duration'].to_i : nil
+                duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
+                summary = wp['summary']
+
+                opts = {:duration => duration}
+                opts[:summary] = summary if summary
+
+                Flapjack::Data::Event.create_acknowledgement(
+                  check.entity_name, check.check, {:redis => redis}.merge(opts))
+              end
+            end
 
-            bulk_api_check_action(entities, checks, act_proc)
             status 204
           end
 
-          app.delete %r{/((?:un)?scheduled_maintenances)} do
-            action = params[:captures][0]
-
-            # no backwards-compatible mode here, it's a new method
-            entities, checks = entities_and_checks(nil, nil)
-
-            act_proc = case action
-            when 'scheduled_maintenances'
-              start_time = validate_and_parsetime(params[:start_time])
-              halt( err(403, "start time must be provided") ) unless start_time
-              opts = {}
-              proc {|entity_check| entity_check.end_scheduled_maintenance(start_time.to_i) }
-            when 'unscheduled_maintenances'
-              end_time = validate_and_parsetime(params[:end_time]) || Time.now
-              proc {|entity_check| entity_check.end_unscheduled_maintenance(end_time.to_i) }
+          app.patch %r{^/unscheduled_maintenances/entities/([^/]+)$} do
+            checks_for_entity_ids( params[:captures][0].split(',') ).each do |check|
+              apply_json_patch('unscheduled_maintenances') do |op, property, linked, value|
+                case op
+                when 'replace'
+                  if ['end_time'].include?(property)
+                    end_time = validate_and_parsetime(value)
+                    check.end_unscheduled_maintenance(end_time.to_i)
+                  end
+                end
+              end
             end
-
-            bulk_api_check_action(entities, checks, act_proc)
             status 204
           end
 
-          app.post %r{/test_notifications#{ENTITY_CHECK_FRAGMENT}} do
-            captures    = params[:captures] || []
-            entity_name = captures[0]
-            check       = captures[1]
-
-            entities, checks = entities_and_checks(entity_name, check)
-
-            act_proc = proc {|entity_check|
-              summary = params[:summary] ||
-                        "Testing notifications to all contacts interested in entity #{entity_check.entity.name}"
-              Flapjack::Data::Event.test_notifications(
-                entity_check.entity_name, entity_check.check,
-                :summary => summary,
-                :redis => redis)
-            }
+          app.delete %r{^/scheduled_maintenances/entities/([^/]+)$} do
+            start_time = validate_and_parsetime(params[:start_time])
+            halt( err(403, "start time must be provided") ) unless start_time
 
-            bulk_api_check_action(entities, checks, act_proc)
+            checks_for_entity_ids(params[:captures][0].split(',')).each do |check|
+              check.end_scheduled_maintenance(start_time.to_i)
+            end
             status 204
           end
 
-          app.post '/entities' do
-            pass unless Flapjack::Gateways::JSONAPI::JSON_REQUEST_MIME_TYPES.include?(request.content_type)
-
-            errors = []
-            ret = nil
-
-            # FIXME should scan for invalid records before making any changes, fail early
-
-            entities = params[:entities]
-            unless entities
-              logger.debug("no entities object found in the following supplied JSON:")
-              logger.debug(request.body)
-              return err(403, "No entities object received")
-            end
-            return err(403, "The received entities object is not an Enumerable") unless entities.is_a?(Enumerable)
-            return err(403, "Entity with a nil id detected") unless entities.any? {|e| !e['id'].nil?}
-
-            entities.each do |entity|
-              unless entity['id']
-                errors << "Entity not imported as it has no id: #{entity.inspect}"
-                next
+          app.post %r{^/test_notifications/entities/([^/]+)$} do
+            test_notifications = wrapped_params('test_notifications', false)
+            checks_for_entity_ids(params[:captures][0].split(',')).each do |check|
+              test_notifications.each do |wp|
+                summary = wp['summary'] ||
+                          "Testing notifications to all contacts interested in entity #{check.entity.name}"
+                Flapjack::Data::Event.test_notifications(
+                  check.entity_name, check.check,
+                  :summary => summary,
+                  :redis => redis)
               end
-              Flapjack::Data::Entity.add(entity, :redis => redis)
             end
-            errors.empty? ? 204 : err(403, *errors)
+            status 204
           end
 
         end

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

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+require 'flapjack/data/contact'
+
+module Flapjack
+
+  module Gateways
+
+    class JSONAPI < Sinatra::Base
+
+      module MediumMethods
+
+        SEMAPHORE_CONTACT_MASS_UPDATE = 'contact_mass_update'
+
+        module Helpers
+
+          def obtain_semaphore(resource)
+            semaphore = nil
+            strikes = 0
+            begin
+              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
+              sleep 1
+              retry
+            end
+            raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) unless semaphore
+            semaphore
+          end
+
+          # TODO validate that media type exists in redis
+          def split_media_ids(media_ids)
+
+            contact_cache = {}
+
+            media_ids.split(',').uniq.collect do |m_id|
+              m_id =~ /\A(.+)_(email|sms|jabber)\z/
+
+              contact_id = $1
+              media_type = $2
+              halt err(422, "Could not get contact_id from media_id") if contact_id.nil?
+              halt err(422, "Could not get media type from media_id") if media_type.nil?
+
+              contact_cache[contact_id] ||= find_contact(contact_id)
+
+              {:contact => contact_cache[contact_id], :type => media_type}
+            end
+          end
+
+        end
+
+        def self.registered(app)
+          app.helpers Flapjack::Gateways::JSONAPI::Helpers
+          app.helpers Flapjack::Gateways::JSONAPI::MediumMethods::Helpers
+
+          # Creates media records for a contact
+          app.post '/contacts/:contact_id/media' do
+            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")
+            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
+
+            media_data.each do |medium_data|
+              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}"
+              medium_data[:links] = {:contacts => [contact.id]}
+            end
+
+            semaphore.release
+
+            status 201
+
+            '{"media":' + media_data.to_json + '}'
+          end
+
+          # get one or more media records; media ids are, for Flapjack
+          # v1, composed of "#{contact.id}_#{media_type}"
+          app.get %r{^/media(?:/)?([^/]+)?$} do
+            media_list_cache = {}
+            contact_media = if params[:captures] && params[:captures][0]
+              split_media_ids(params[:captures][0])
+            else
+              Flapjack::Data::Contact.all(:redis => redis).collect do |contact|
+                media_list_cache[contact.id] ||= contact.media_list
+                media_list_cache[contact.id].collect do |media_type|
+                  {:contact => contact, :type => media_type}
+                end
+              end.flatten(1)
+            end
+
+            media_data = contact_media.inject([]) do |memo, contact_media_type|
+              contact = contact_media_type[:contact]
+              media_type = contact_media_type[:type]
+
+              media_list_cache[contact.id] ||= contact.media_list
+              if media_list_cache[contact.id].include?(media_type)
+                medium_id = "#{contact.id}_#{media_type}"
+                memo <<
+                  {:id               => medium_id,
+                   :type             => media_type,
+                   :address          => contact.media[media_type],
+                   :interval         => contact.media_intervals[media_type],
+                   :rollup_threshold => contact.media_rollup_thresholds[media_type],
+                   :links            => {:contacts => [contact.id]}}
+              end
+
+              memo
+            end
+
+            '{"media":' + media_data.to_json + '}'
+          end
+
+          # update one or more media records; media ids are, for Flapjack
+          # v1, composed of "#{contact.id}_#{media_type}"
+          app.patch '/media/:id' do
+            media_list_cache = {}
+            split_media_ids(params[:id]).each do |contact_media_type|
+              contact = contact_media_type[:contact]
+              media_type = contact_media_type[:type]
+              media_list_cache[contact.id] ||= contact.media_list
+              next unless media_list_cache[contact.id].include?(media_type)
+              apply_json_patch('media') do |op, property, linked, value|
+                if 'replace'.eql?(op)
+                  case property
+                  when 'address'
+                    contact.set_address_for_media(media_type, value)
+                  when 'interval'
+                    contact.set_interval_for_media(media_type, value)
+                  when 'rollup_threshold'
+                    contact.set_rollup_threshold_for_media(media_type, value)
+                  end
+                end
+              end
+            end
+
+            status 204
+          end
+
+          # delete one or more media records; media ids are, for Flapjack
+          # v1, composed of "#{contact.id}_#{media_type}"
+          app.delete '/media/:id' do
+            media_list_cache = {}
+            split_media_ids(params[:id]).each do |contact_media_type|
+              contact = contact_media_type[:contact]
+              media_type = contact_media_type[:type]
+              media_list_cache[contact.id] ||= contact.media_list
+              next unless media_list_cache[contact.id].include?(media_type)
+              contact.remove_media(media_type)
+            end
+            status 204
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end