flapjack 0.6.43 → 0.6.44

data/lib/flapjack/coordinator.rb

@@ -11,18 +11,14 @@ require 'em-resque'
 require 'em-resque/worker'
 require 'thin'
 
+require 'flapjack/configuration'
 require 'flapjack/patches'
-
-require 'flapjack/api'
 require 'flapjack/daemonizing'
 require 'flapjack/executive'
-require 'flapjack/jabber'
-require 'flapjack/oobetet'
-require 'flapjack/pagerduty'
-require 'flapjack/notification/email'
-require 'flapjack/notification/sms'
 require 'flapjack/redis_pool'
-require 'flapjack/web'
+
+require 'flapjack/pikelet'
+require 'flapjack/gateways/base'
 
 module Flapjack
 
@@ -30,9 +26,9 @@ module Flapjack
 
     include Flapjack::Daemonizable
 
-    def initialize(config, redis_options)
+    def initialize(config)
       @config = config
-      @redis_options = redis_options
+      @redis_options = config.for_redis
       @pikelets = []
 
       @logger = Log4r::Logger.new("flapjack-coordinator")
@@ -62,31 +58,19 @@ module Flapjack
 
   private
 
-    # map from config key to pikelet class
-    PIKELET_TYPES = {'executive'          => Flapjack::Executive,
-                     'jabber_gateway'     => Flapjack::Jabber,
-                     'pagerduty_gateway'  => Flapjack::Pagerduty,
-                     'oobetet'            => Flapjack::Oobetet,
-
-                     'web'                => Flapjack::Web,
-                     'api'                => Flapjack::API,
-
-                     'email_notifier'     => Flapjack::Notification::Email,
-                     'sms_notifier'       => Flapjack::Notification::Sms}
-
     def run(options = {})
 
       EM.synchrony do
-        @logger.debug "config keys: #{@config.keys}"
 
-        @config.keys.each do |pikelet_type|
-          next unless PIKELET_TYPES.keys.include?(pikelet_type) &&
-            @config[pikelet_type].is_a?(Hash) &&
-            @config[pikelet_type]['enabled']
-          @logger.debug "coordinator is now initialising the #{pikelet_type} pikelet"
-          pikelet_cfg = @config[pikelet_type]
+        @config.pikelets.each_pair do |pikelet_class, pikelet_cfg|
+          next unless pikelet_cfg['enabled']
+          build_pikelet(pikelet_class, pikelet_cfg)
+        end
 
-          build_pikelet(pikelet_type, pikelet_cfg)
+        @config.gateways.each_pair do |gateway_class, gateway_cfg|
+          # TODO split out gateway logic to build_gateway
+          next unless gateway_cfg['enabled']
+          build_pikelet(gateway_class, gateway_cfg)
         end
 
         setup_signals if @signals
@@ -106,8 +90,8 @@ module Flapjack
       end
     end
 
-    def build_pikelet(pikelet_type, pikelet_cfg)
-      return unless pikelet_class = PIKELET_TYPES[pikelet_type]
+    def build_pikelet(pikelet_class, pikelet_cfg)
+      @logger.debug "coordinator is now initialising the #{pikelet_class} pikelet"
 
       inc_mod = pikelet_class.included_modules
       ext_mod = extended_modules(pikelet_class)
@@ -118,11 +102,10 @@ module Flapjack
       if inc_mod.include?(Flapjack::GenericPikelet)
         pikelet = pikelet_class.new
         pikelet.bootstrap(:config => pikelet_cfg, :redis_config => @redis_options)
-
       else
         pikelet_class.bootstrap(:config => pikelet_cfg, :redis_config => @redis_options)
 
-        if ext_mod.include?(Flapjack::ThinPikelet)
+        if ext_mod.include?(Flapjack::Gateways::Thin)
 
           unless @thin_silenced
             Thin::Logging.silent = true
@@ -133,7 +116,7 @@ module Flapjack
                       pikelet_class.instance_variable_get('@port'),
                       pikelet_class, :signals => false)
 
-        elsif ext_mod.include?(Flapjack::ResquePikelet)
+        elsif ext_mod.include?(Flapjack::Gateways::Resque)
 
           # set up connection pooling, stop resque errors
           unless @resque_pool
@@ -155,14 +138,14 @@ module Flapjack
       pikelet_info = {:class => pikelet_class, :instance => pikelet}
 
       if inc_mod.include?(Flapjack::GenericPikelet) ||
-        ext_mod.include?(Flapjack::ResquePikelet)
+        ext_mod.include?(Flapjack::Gateways::Resque)
 
         fiber = Fiber.new {
           begin
             # Can't use local inc_mod/ext_mod variables in the new fiber
             if pikelet.is_a?(Flapjack::GenericPikelet)
               pikelet.main
-            elsif extended_modules(pikelet_class).include?(Flapjack::ResquePikelet)
+            elsif extended_modules(pikelet_class).include?(Flapjack::Gateways::Resque)
               pikelet.work(0.1)
             end
           rescue Exception => e
@@ -174,10 +157,10 @@ module Flapjack
 
         pikelet_info[:fiber] = fiber
         fiber.resume
-        @logger.debug "new fiber created for #{pikelet_type}"
-      elsif ext_mod.include?(Flapjack::ThinPikelet)
+        @logger.debug "new fiber created for #{pikelet_class}"
+      elsif ext_mod.include?(Flapjack::Gateways::Thin)
         pikelet.start
-        @logger.debug "new thin server instance started for #{pikelet_type}"
+        @logger.debug "new thin server instance started for #{pikelet_class}"
       end
 
       @pikelets << pikelet_info
@@ -187,7 +170,7 @@ module Flapjack
     # cause everything else to be spammy
     def health_check
       @pikelets.each do |pik|
-        status = if extended_modules(pik[:class]).include?(Flapjack::ThinPikelet)
+        status = if extended_modules(pik[:class]).include?(Flapjack::Gateways::Thin)
           pik[:instance].backend.size > 0 ? 'running' : 'stopped'
         elsif pik[:fiber]
           pik[:fiber].alive? ? 'running' : 'stopped'
@@ -217,10 +200,10 @@ module Flapjack
               r.quit
             }.resume
           end
-        elsif ext_mod.include?(Flapjack::ResquePikelet)
+        elsif ext_mod.include?(Flapjack::Gateways::Resque)
           # resque is polling, so we don't need a shutdown object
           pik_inst.shutdown if pik[:fiber] && pik[:fiber].alive?
-        elsif ext_mod.include?(Flapjack::ThinPikelet)
+        elsif ext_mod.include?(Flapjack::Gateways::Thin)
           # drop from this side, as HTTP keepalive etc. means browsers
           # keep connections alive for ages, and we'd be hanging around
           # waiting for them to drop
@@ -247,7 +230,7 @@ module Flapjack
 
                 pik_inst.cleanup
 
-              elsif [Flapjack::ResquePikelet, Flapjack::ThinPikelet].any?{|fp|
+              elsif [Flapjack::Gateways::Resque, Flapjack::Gateways::Thin].any?{|fp|
                 ext_mod.include?(fp)
               }
 

data/lib/flapjack/data/entity.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'flapjack/data/contact'
+
 module Flapjack
 
   module Data
@@ -31,8 +33,9 @@ module Flapjack
 
           redis.del("contacts_for:#{entity['id']}")
           if entity['contacts'] && entity['contacts'].respond_to?(:each)
-            entity['contacts'].each {|contact|
-              redis.sadd("contacts_for:#{entity['id']}", contact)
+            entity['contacts'].each {|contact_id|
+              next if Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis).nil?
+              redis.sadd("contacts_for:#{entity['id']}", contact_id)
             }
           end
         else
@@ -62,13 +65,31 @@ module Flapjack
         self.new(:name => entity_name, :id => entity_id, :redis => redis)
       end
 
+      # NB: if we're worried about user input, https://github.com/mudge/re2
+      # has bindings for a non-backtracking RE engine that runs in linear
+      # time
       def self.find_all_name_matching(pattern, options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        matched_entities = redis.keys('check:*').collect {|check|
-          a, entity, c = check.split(':')
-          match = (entity =~ /#{pattern}/) ? entity : nil
-        }
-        matched_entities.compact.sort.uniq
+        redis.keys('entity_id:*').inject([]) {|memo, check|
+          a, entity_name = check.split(':')
+          if (entity_name =~ /#{pattern}/) && !memo.include?(entity_name)
+            memo << entity_name
+          end
+          memo
+        }.sort
+      end
+
+      def contacts
+        contact_ids = @redis.smembers("contacts_for:#{id}")
+
+        if @logger
+          @logger.debug("#{contact_ids.length} contact(s) for #{id} (#{name}): " +
+            contact_ids.length)
+        end
+
+        contact_ids.collect {|c_id|
+          Flapjack::Data::Contact.find_by_id(c_id, :redis => @redis)
+        }.compact
       end
 
       def check_list

data/lib/flapjack/data/entity_check.rb

@@ -4,6 +4,7 @@ require 'yajl/json_gem'
 
 require 'flapjack/patches'
 
+require 'flapjack/data/contact'
 require 'flapjack/data/entity'
 
 # TODO might want to split the class methods out to a separate class, DAO pattern
@@ -49,7 +50,7 @@ module Flapjack
       end
 
       def entity_name
-        @entity.name
+        entity.name
       end
 
       # takes a key "entity:check", returns true if the check is in unscheduled
@@ -74,24 +75,26 @@ module Flapjack
         }
       end
 
+      # TODO move to Event
       def create_acknowledgement(options = {})
         event = { 'type'               => 'action',
                   'state'              => 'acknowledgement',
                   'summary'            => options['summary'],
                   'duration'           => options['duration'],
                   'acknowledgement_id' => options['acknowledgement_id'],
-                  'entity'             => @entity.name,
-                  'check'              => @check
+                  'entity'             => entity.name,
+                  'check'              => check
                 }
         Flapjack::Data::Event.add(event, :redis => @redis)
       end
 
+      # TODO move to Event
       def test_notifications(options = {})
         event = { 'type'               => 'action',
                   'state'              => 'test_notifications',
                   'summary'            => options['summary'],
-                  'entity'             => @entity.name,
-                  'check'              => @check
+                  'entity'             => entity.name,
+                  'check'              => check
                 }
         Flapjack::Data::Event.add(event, :redis => @redis)
       end
@@ -405,8 +408,6 @@ module Flapjack
       # has pagerduty credentials then there'll be one hash in the array for each set of
       # credentials.
       def pagerduty_credentials(options)
-        # raise "Redis connection not set" unless redis = options[:redis]
-
         self.contacts.inject([]) {|ret, contact|
           cred = contact.pagerduty_credentials
           ret << cred if cred
@@ -417,28 +418,25 @@ module Flapjack
       # takes a check, looks up contacts that are interested in this check (or in the check's entity)
       # and returns an array of contact records
       def contacts
-        entity = @entity
-        check  = @check
+        contact_ids = @redis.smembers("contacts_for:#{entity.id}:#{check}")
 
         if @logger
-          @logger.debug("contacts for #{@entity.id} (#{@entity.name}): " +
-            @redis.smembers("contacts_for:#{@entity.id}").length.to_s)
-          @logger.debug("contacts for #{check}: " +
-            @redis.smembers("contacts_for:#{check}").length.to_s)
+          @logger.debug("#{contact_ids.length} contact(s) for #{entity.id}:#{check}: " +
+            contact_ids.inspect)
         end
 
-        union = @redis.sunion("contacts_for:#{@entity.id}", "contacts_for:#{check}")
-        @logger.debug("contacts for union of #{@entity.id} and #{check}: " + union.length.to_s) if @logger
-        union.collect {|c_id| Flapjack::Data::Contact.find_by_id(c_id, :redis => @redis) }
+        entity.contacts + contact_ids.collect {|c_id|
+          Flapjack::Data::Contact.find_by_id(c_id, :redis => @redis)
+        }.compact
       end
 
     private
 
-      def initialize(entity, check, options = {})
+      def initialize(ent, che, options = {})
         raise "Redis connection not set" unless @redis = options[:redis]
-        raise "Invalid entity" unless @entity = entity
-        raise "Invalid check" unless @check = check
-        @key = "#{entity.name}:#{check}"
+        raise "Invalid entity" unless @entity = ent
+        raise "Invalid check" unless @check = che
+        @key = "#{ent.name}:#{che}"
       end
 
       def validate_state(state)

data/lib/flapjack/executive.rb

@@ -14,11 +14,12 @@ require 'flapjack/data/contact'
 require 'flapjack/data/entity_check'
 require 'flapjack/data/notification'
 require 'flapjack/data/event'
-require 'flapjack/notification/sms'
-require 'flapjack/notification/email'
 require 'flapjack/pikelet'
 require 'flapjack/redis_pool'
 
+require 'flapjack/gateways/email'
+require 'flapjack/gateways/sms'
+
 module Flapjack
 
   class Executive
@@ -255,9 +256,9 @@ module Flapjack
         # TODO consider changing Resque jobs to use raw blpop like the others
         case media_type
         when :sms
-          Resque.enqueue_to(@queues[:sms], Flapjack::Notification::Sms, contents)
+          Resque.enqueue_to(@queues[:sms], Flapjack::Gateways::Sms, contents)
         when :email
-          Resque.enqueue_to(@queues[:email], Flapjack::Notification::Email, contents)
+          Resque.enqueue_to(@queues[:email], Flapjack::Gateways::Email, contents)
         when :jabber
           # TODO move next line up into other notif value setting above?
           contents['event_count'] = @event_count if @event_count

data/lib/flapjack/gateways/api.rb

@@ -0,0 +1,391 @@
+#!/usr/bin/env ruby
+
+# A HTTP-based API server, which provides queries to determine the status of
+# entities and the checks that are reported against them.
+#
+# There's a matching flapjack-diner gem at https://github.com/flpjck/flapjack-diner
+# which consumes data from this API.
+
+require 'time'
+
+require 'async-rack'
+require 'rack/fiber_pool'
+require 'sinatra/base'
+
+require 'flapjack/data/contact'
+require 'flapjack/data/entity'
+require 'flapjack/data/entity_check'
+
+require 'flapjack/gateways/api/entity_presenter'
+require 'flapjack/rack_logger'
+require 'flapjack/redis_pool'
+
+require 'flapjack/gateways/base'
+
+# from https://github.com/sinatra/sinatra/issues/501
+# TODO move to its own file
+module Rack
+  class JsonParamsParser < Struct.new(:app)
+    def call(env)
+      if env['rack.input'] and not input_parsed?(env) and type_match?(env)
+        env['rack.request.form_input'] = env['rack.input']
+        data = env['rack.input'].read
+        env['rack.request.form_hash'] = data.empty?? {} : JSON.parse(data)
+      end
+      app.call(env)
+    end
+
+    def input_parsed? env
+      env['rack.request.form_input'].eql? env['rack.input']
+    end
+
+    def type_match? env
+      type = env['CONTENT_TYPE'] and
+        type.split(/\s*[;,]\s*/, 2).first.downcase == 'application/json'
+    end
+  end
+end
+
+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]
+        }
+
+        use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
+      end
+      use Rack::MethodOverride
+      use Rack::JsonParamsParser
+
+      class << self
+        include Flapjack::Gateways::Thin
+
+        attr_accessor :redis
+
+        alias_method :thin_bootstrap, :bootstrap
+        alias_method :thin_cleanup,   :cleanup
+
+        def bootstrap(opts = {})
+          thin_bootstrap(opts)
+          @redis = Flapjack::RedisPool.new(:config => opts[:redis_config], :size => 1)
+
+          if config && config['access_log']
+            access_logger = Flapjack::RackLogger.new(config['access_log'])
+            use Rack::CommonLogger, access_logger
+          end
+        end
+
+        def cleanup
+          @redis.empty! if @redis
+          thin_cleanup
+        end
+
+      end
+
+      def redis
+        self.class.instance_variable_get('@redis')
+      end
+
+      def logger
+        self.class.instance_variable_get('@logger')
+      end
+
+      get '/entities' do
+        content_type :json
+        ret = Flapjack::Data::Entity.all(:redis => redis).sort_by(&:name).collect {|e|
+          {'id' => e.id, 'name' => e.name,
+           'checks' => e.check_list.sort.collect {|c|
+                         entity_check_status(e, c)
+                       }
+          }
+        }
+        ret.to_json
+      end
+
+      get '/checks/:entity' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+        entity.check_list.to_json
+      end
+
+      get %r{/status/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(\w+))?} do
+        content_type :json
+
+        entity_name = params[:captures][0]
+        check = params[:captures][1]
+
+        entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        ret = if check
+          entity_check_status(entity, check)
+        else
+          entity.check_list.sort.collect {|c|
+            entity_check_status(entity, c)
+          }
+        end
+        ret.to_json
+      end
+
+      # the first capture group in the regex checks for acceptable
+      # characters in a domain name -- this will also match strings
+      # that aren't acceptable domain names as well, of course.
+      get %r{/outages/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(\w+))?} do
+        content_type :json
+
+        entity_name = params[:captures][0]
+        check = params[:captures][1]
+
+        entity = entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        start_time = validate_and_parsetime(params[:start_time])
+        end_time   = validate_and_parsetime(params[:end_time])
+
+        presenter = if check
+          entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+            check, :redis => redis)
+          Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
+        else
+          Flapjack::Gateways::API::EntityPresenter.new(entity, :redis => redis)
+        end
+
+        presenter.outages(start_time, end_time).to_json
+      end
+
+      get %r{/unscheduled_maintenances/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(\w+))?} do
+        content_type :json
+
+        entity_name = params[:captures][0]
+        check = params[:captures][1]
+
+        entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        start_time = validate_and_parsetime(params[:start_time])
+        end_time   = validate_and_parsetime(params[:end_time])
+
+        presenter = if check
+          entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+            check, :redis => redis)
+          Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
+        else
+          Flapjack::Gateways::API::EntityPresenter.new(entity, :redis => redis)
+        end
+
+        presenter.unscheduled_maintenance(start_time, end_time).to_json
+      end
+
+      get %r{/scheduled_maintenances/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(\w+))?} do
+        content_type :json
+
+        entity_name = params[:captures][0]
+        check = params[:captures][1]
+
+        entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        start_time = validate_and_parsetime(params[:start_time])
+        end_time   = validate_and_parsetime(params[:end_time])
+
+        presenter = if check
+          entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+            check, :redis => redis)
+          Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
+        else
+          Flapjack::Gateways::API::EntityPresenter.new(entity, :redis => redis)
+        end
+        presenter.scheduled_maintenance(start_time, end_time).to_json
+      end
+
+      get %r{/downtime/([a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])(?:/(\w+))?} do
+        content_type :json
+
+        entity_name = params[:captures][0]
+        check = params[:captures][1]
+
+        entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        start_time = validate_and_parsetime(params[:start_time])
+        end_time   = validate_and_parsetime(params[:end_time])
+
+        presenter = if check
+          entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+            check, :redis => redis)
+          Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
+        else
+          Flapjack::Gateways::API::EntityPresenter.new(entity, :redis => redis)
+        end
+
+        presenter.downtime(start_time, end_time).to_json
+      end
+
+      # create a scheduled maintenance period for a service on an entity
+      post '/scheduled_maintenances/:entity/:check' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+        entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+          params[:check], :redis => redis)
+        entity_check.create_scheduled_maintenance(:start_time => params[:start_time],
+          :duration => params[:duration], :summary => params[:summary])
+        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
+      post '/acknowledgements/:entity/:check' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        dur = params[:duration] ? params[:duration].to_i : nil
+        duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
+
+        entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+          params[:check], :redis => redis)
+        entity_check.create_acknowledgement('summary' => params[:summary],
+          'duration' => duration)
+        status 204
+      end
+
+      post '/test_notifications/:entity/:check' do
+        content_type :json
+        entity = Flapjack::Data::Entity.find_by_name(params[:entity], :redis => redis)
+        if entity.nil?
+          status 404
+          return
+        end
+
+        summary = params[:summary] || "Testing notifications to all contacts interested in entity #{entity.name}"
+
+        entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+          params[:check], :redis => redis)
+        entity_check.test_notifications('summary' => summary)
+        status 204
+      end
+
+      post '/entities' do
+        pass unless 'application/json'.eql?(request.content_type)
+        content_type :json
+
+        errors = []
+        ret = nil
+
+        entities = params[:entities]
+        if entities && entities.is_a?(Enumerable) && 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
+            end
+            Flapjack::Data::Entity.add(entity, :redis => redis)
+          end
+          ret = 200
+        else
+          ret = 403
+          errors << "No valid entities were submitted"
+        end
+        errors.empty? ? ret : [ret, {}, {:errors => [errors]}.to_json]
+      end
+
+      post '/contacts' do
+        pass unless 'application/json'.eql?(request.content_type)
+        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
+            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]
+      end
+
+      not_found do
+        [404, {}, {:errors => ["Not found"]}.to_json]
+      end
+
+      private
+
+      def entity_check_status(entity, check)
+        entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+          check, :redis => redis)
+        return if entity_check.nil?
+        { 'name'                                => check,
+          'state'                               => entity_check.state,
+          'in_unscheduled_maintenance'          => entity_check.in_unscheduled_maintenance?,
+          'in_scheduled_maintenance'            => entity_check.in_scheduled_maintenance?,
+          'last_update'                         => entity_check.last_update,
+          'last_problem_notification'           => entity_check.last_problem_notification,
+          'last_recovery_notification'          => entity_check.last_recovery_notification,
+          'last_acknowledgement_notification'   => entity_check.last_acknowledgement_notification
+        }
+      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
+
+  end
+
+end