flapjack 1.6.0 → 2.0.0b1

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

@@ -1,186 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/contact'
-require 'flapjack/data/notification_rule'
-require 'flapjack/data/semaphore'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module ContactMethods
-
-        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) if strikes >= 3
-              sleep 1
-              retry
-            end
-            raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) if semaphore.nil?
-            semaphore
-          end
-
-          def bulk_contact_operation(contact_ids, &block)
-            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
-
-            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
-
-            missing_ids = contacts_by_id.select {|k, v| v.nil? }.keys
-            unless missing_ids.empty?
-              semaphore.release
-              raise Flapjack::Gateways::JSONAPI::ContactsNotFound.new(missing_ids)
-            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
-            contacts_data = params[:contacts]
-
-            if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
-              halt err(422, "No valid contacts were submitted")
-            end
-
-            contacts_ids = contacts_data.reject {|c| c['id'].nil? }.
-              map {|co| co['id'].to_s }
-
-            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
-
-            conflicted_ids = contacts_ids.find_all {|id|
-              Flapjack::Data::Contact.exists_with_id?(id, :redis => redis)
-            }
-
-            unless conflicted_ids.empty?
-              semaphore.release
-              halt err(409, "Contacts already exist with the following IDs: " +
-                conflicted_ids.join(', '))
-            end
-
-            contacts_data.each do |contact_data|
-              unless contact_data['id']
-                contact_data['id'] = SecureRandom.uuid
-              end
-              Flapjack::Data::Contact.add(contact_data, :redis => redis)
-            end
-
-            semaphore.release
-
-            contact_ids = contacts_data.map {|c| c['id']}
-
-            response.headers['Location'] = "#{base_url}/contacts/#{contact_ids.join(',')}"
-            status 201
-            Flapjack.dump_json(contact_ids)
-          end
-
-          # Returns all (/contacts) or some (/contacts/1,2,3) or one (/contacts/2) contact(s)
-          # http://flapjack.io/docs/1.0/jsonapi/#contacts
-          app.get %r{^/contacts(?:/)?([^/]+)?$} do
-            requested_contacts = if params[:captures] && params[:captures][0]
-              params[:captures][0].split(',').uniq
-            else
-              nil
-            end
-
-            contacts = if requested_contacts
-              Flapjack::Data::Contact.find_by_ids(requested_contacts, :logger => logger, :redis => redis)
-            else
-              Flapjack::Data::Contact.all(:redis => redis).reject {|c| c.id.nil? || c.id.empty? }
-            end
-            contacts.compact!
-
-            if requested_contacts && contacts.empty?
-              raise Flapjack::Gateways::JSONAPI::ContactsNotFound.new(requested_contacts)
-            end
-
-            entity_ids = contacts.empty? ? [] : Flapjack::Data::Contact.entity_ids_for(contacts.map(&:id), :redis => redis)
-
-            contacts_json = contacts.collect {|contact|
-              contact.to_jsonapi(:entity_ids => entity_ids[contact.id])
-            }.join(", ")
-
-            '{"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', 'timezone'].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
-
-            status 204
-          end
-
-          # Delete one or more contacts
-          app.delete '/contacts/:id' do
-            bulk_contact_operation(params[:id].split(',')) do |contacts|
-              contacts.each {|contact| contact.delete!}
-            end
-
-            status 204
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,223 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/entity'
-require 'flapjack/data/entity_check'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module EntityMethods
-
-        module Helpers
-
-          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 self.registered(app)
-          app.helpers Flapjack::Gateways::JSONAPI::Helpers
-          app.helpers Flapjack::Gateways::JSONAPI::EntityMethods::Helpers
-
-          # 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
-
-            entities = if requested_entities
-              Flapjack::Data::Entity.find_by_ids(requested_entities, :logger => logger, :redis => redis)
-            else
-              enabled = if params.has_key?(:enabled)
-                case params[:enabled].downcase
-                when '0', 'f', 'false', 'n', 'no'
-                  false
-                when '1', 't', 'true', 'y', 'yes'
-                  true
-                else
-                  nil
-                end
-              else
-                nil
-              end
-
-              Flapjack::Data::Entity.all(:enabled => enabled,
-                :redis => redis).reject {|e| e.id.nil? || e.id.empty? }
-            end
-            entities.compact!
-
-            if requested_entities && entities.empty?
-              raise Flapjack::Gateways::JSONAPI::EntitiesNotFound.new(requested_entities)
-            end
-
-            entity_ids = entities.map(&:id)
-            linked_contact_ids = entities.empty? ? [] :
-              Flapjack::Data::Entity.contact_ids_for(entity_ids, :redis => redis)
-            linked_check_ids   = entities.empty? ? [] :
-              Flapjack::Data::Entity.check_ids_for(entity_ids, :redis => redis)
-
-            entities_json = entities.collect {|entity|
-              entity_id = entity.id
-              entity.to_jsonapi(:contact_ids => linked_contact_ids[entity_id],
-                                :check_ids   => linked_check_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?}
-
-            entity_ids = entities.collect{|entity_data|
-              Flapjack::Data::Entity.add(entity_data, :redis => redis)
-              entity_data['id']
-            }
-
-            response.headers['Location'] = "#{request.base_url}/entities/#{entity_ids.join(',')}"
-            status 201
-            Flapjack.dump_json(entity_ids)
-          end
-
-          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'.eql?(property)
-                    name = entity.name
-                    if name != value
-                      existing = Flapjack::Data::Entity.find_by_name(value, :redis => redis)
-                      Flapjack::Data::Entity.send(existing.nil? ? :rename : :merge,
-                        name, value, :redis => redis)
-                    end
-                  end
-                when 'add'
-                  case linked
-                  when 'contacts'
-                    contact = Flapjack::Data::Contact.find_by_id(value, :redis => redis)
-                    contact.add_entity(entity) unless contact.nil?
-                  when 'tags'
-                    value.respond_to?(:each) ? entity.add_tags(*value) :
-                                               entity.add_tags(value)
-                  end
-                when 'remove'
-                  case linked
-                  when 'contacts'
-                    contact = Flapjack::Data::Contact.find_by_id(value, :redis => redis)
-                    contact.remove_entity(entity) unless contact.nil?
-                  when 'tags'
-                    value.respond_to?(:each) ? entity.delete_tags(*value) :
-                                               entity.delete_tags(value)
-                  end
-                end
-              end
-            end
-
-            status 204
-          end
-
-          # create a scheduled maintenance period for a check on an entity
-          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
-
-            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{^/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
-
-            status 204
-          end
-
-          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
-            status 204
-          end
-
-          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
-
-            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 %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
-            end
-            status 204
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,185 +0,0 @@
-#!/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 = {}
-
-            known_media_identifiers = Flapjack::Data::Contact::ALL_MEDIA.reject{|m| m == 'pagerduty'}.join('|')
-            media_ids.split(',').uniq.collect do |m_id|
-              m_id =~ /\A(.+)_(#{known_media_identifiers})\z/
-
-              contact_id = $1
-              media_type = $2
-              halt err(422, "Could not get contact_id from media_id '#{m_id}'") if contact_id.nil?
-              halt err(422, "Could not get media type from media_id '#{m_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
-
-            media_id_re = /^#{params[:contact_id]}_(?:#{Flapjack::Data::Contact::ALL_MEDIA.join('|')}$)/
-
-            unless media_data.all? {|m| m['id'].nil? || media_id_re === m['id'] }
-              halt err(422, "Media creation cannot include non-conformant 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}"
-            end
-
-            semaphore.release
-
-            media_ids = media_data.collect {|md| md['id']}
-
-            status 201
-            response.headers['Location'] = "#{base_url}/media/#{media_ids.join(',')}"
-            Flapjack.dump_json(media_ids)
-          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}"
-                int = contact.media_intervals[media_type]
-                rut = contact.media_rollup_thresholds[media_type]
-                memo <<
-                  {:id               => medium_id,
-                   :type             => media_type,
-                   :address          => contact.media[media_type],
-                   :interval         => int.nil? ? nil : int.to_i,
-                   :rollup_threshold => rut.nil? ? nil : rut.to_i,
-                   :links            => {:contacts => [contact.id]}}
-              end
-
-              memo
-            end
-
-            '{"media":' + Flapjack.dump_json(media_data) + '}'
-          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