flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/gateways/sms_nexmo/alert.text.erb

@@ -1,6 +1,6 @@
 <% summary = @alert.summary -%>
-<%= @alert.type_sentence_case %>: '<%= @alert.check %>' on <%= @alert.entity -%>
+<%= @alert.type_sentence_case %>: '<%= @alert.check.name %>' -%>
 <% unless ['acknowledgement', 'test'].include?(@alert.notification_type) -%>
  is <%= @alert.state_title_case -%>
 <% end -%>
- at <%= Time.at(@alert.time).strftime('%-d %b %H:%M') %><%= (summary.nil? || summary.empty?) ? '' : ", #{summary}" -%>
+ at <%= Time.at(@alert.time).strftime('%-d %b %H:%M') %><%= (summary.nil? || summary.empty?) ? '' : ", #{summary}" -%>

data/lib/flapjack/gateways/sms_nexmo/rollup.text.erb

@@ -1,2 +1,2 @@
 <%= @alert.type_sentence_case %>: <%= @alert.rollup_states_summary -%>
- (<%= @alert.rollup_states_detail_text(:max_checks_per_state => 3) -%>)
+ (<%= @alert.rollup_states_detail_text(:max_checks_per_state => 3) -%>)

data/lib/flapjack/gateways/sms_twilio.rb

@@ -1,13 +1,18 @@
 #!/usr/bin/env ruby
 
-require 'em-synchrony'
-require 'em-synchrony/em-http'
+require 'net/http'
+require 'uri'
+require 'uri/https'
+
 require 'active_support/inflector'
 
-require 'flapjack/redis_pool'
+require 'flapjack/redis_proxy'
+require 'flapjack/record_queue'
+require 'flapjack/utility'
+require 'flapjack/exceptions'
 
 require 'flapjack/data/alert'
-require 'flapjack/utility'
+require 'flapjack/data/check'
 
 module Flapjack
   module Gateways
@@ -19,83 +24,86 @@ module Flapjack
       # --data-urlencode 'Body=Sausage' \
       # -u [AccountSid]:[AuthToken]
 
+      TWILIO_DEFAULT_HOST = 'api.twilio.com'
+
+      attr_accessor :sent
+
       include Flapjack::Utility
 
       def initialize(opts = {})
+        @lock = opts[:lock]
+
         @config = opts[:config]
-        @logger = opts[:logger]
-        @redis_config = opts[:redis_config] || {}
-        @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 1, :logger => @logger)
 
-        @logger.info("starting")
-        @logger.debug("new sms_twilio gateway pikelet with the following options: #{@config.inspect}")
+        # TODO support for config reloading
+        @queue = Flapjack::RecordQueue.new(@config['queue'] || 'sms_twilio_notifications',
+                   Flapjack::Data::Alert)
 
         @sent = 0
-      end
-
-      def stop
-        @logger.info("stopping")
-        @should_quit = true
 
-        redis_uri = @redis_config[:path] ||
-          "redis://#{@redis_config[:host] || '127.0.0.1'}:#{@redis_config[:port] || '6379'}/#{@redis_config[:db] || '0'}"
-        shutdown_redis = EM::Hiredis.connect(redis_uri)
-        shutdown_redis.rpush(@config['queue'], Flapjack.dump_json('notification_type' => 'shutdown'))
+        Flapjack.logger.debug("new sms_twilio gateway pikelet with the following options: #{@config.inspect}")
       end
 
       def start
-        queue = @config['queue']
-
-        until @should_quit
-          begin
-            @logger.debug("sms_twilio gateway is going into blpop mode on #{queue}")
-            alert = Flapjack::Data::Alert.next(queue, :redis => @redis, :logger => @logger)
-            deliver(alert) unless alert.nil?
-          rescue => e
-            @logger.error "Error generating or dispatching SMS Twilio message: #{e.class}: #{e.message}\n" +
-              e.backtrace.join("\n")
+        begin
+          Zermelo.redis = Flapjack.redis
+
+          loop do
+            @lock.synchronize do
+              @queue.foreach {|alert| handle_alert(alert) }
+            end
+
+            @queue.wait
           end
+        ensure
+          Flapjack.redis.quit
         end
       end
 
-      def deliver(alert)
+      def stop_type
+        :exception
+      end
+
+      private
+
+      def handle_alert(alert)
         account_sid = @config["account_sid"]
-        auth_token  = @config["auth_token"]
-        from        = @config["from"]
-        endpoint    = @config["endpoint"] || "https://api.twilio.com/2010-04-01/Accounts/#{account_sid}/Messages.json"
+        auth_token = @config["auth_token"]
+        from = @config["from"]
+
+        endpoint_host = @config["endpoint_host"] || TWILIO_DEFAULT_HOST
+        endpoint_path = @config["endpoint_path"] || "/2010-04-01/Accounts/#{account_sid}/Messages.json"
 
-        address         = alert.address
-        notification_id = alert.notification_id
-        message_type    = alert.rollup ? 'rollup' : 'alert'
+        address = alert.medium.address
+        notification_id = alert.id
+        message_type = alert.rollup ? 'rollup' : 'alert'
 
+        sms_dir = File.join(File.dirname(__FILE__), 'sms_twilio')
         sms_template_erb, sms_template =
-          load_template(@config['templates'], message_type, 'text',
-                        File.join(File.dirname(__FILE__), 'sms_twilio'))
+          load_template(@config['templates'], message_type, 'text', sms_dir)
 
-        @alert  = alert
-        bnd     = binding
+        @alert = alert
+        bnd = binding
 
         begin
           message = sms_template_erb.result(bnd).chomp
         rescue => e
-          @logger.error "Error while executing the ERB for an sms: " +
+          Flapjack.logger.error "Error while executing the ERB for an sms: " +
             "ERB being executed: #{sms_template}"
           raise
         end
 
         if @config.nil? || (@config.respond_to?(:empty?) && @config.empty?)
-          @logger.error "sms_twilio config is missing"
+          Flapjack.logger.error "sms twilio config is missing"
           return
         end
 
         errors = []
 
-        safe_message = truncate(message, 159)
-
         [[account_sid, "Twilio account_sid is missing"],
          [auth_token, "Twilio auth_token is missing"],
-         [from,  "SMS from address is missing"],
-         [address,  "SMS address is missing"],
+         [from, "SMS from address is missing"],
+         [address, "SMS address is missing"],
          [notification_id, "Notification id is missing"]].each do |val_err|
 
           next unless val_err.first.nil? || (val_err.first.respond_to?(:empty?) && val_err.first.empty?)
@@ -103,33 +111,42 @@ module Flapjack
         end
 
         unless errors.empty?
-          errors.each {|err| @logger.error err }
+          errors.each {|err| Flapjack.logger.error err }
           return
         end
 
-        body_data = {'To'   => address,
-                 'From' => from,
-                 'Body' => safe_message}
-        @logger.debug "body_data: #{body_data.inspect}"
-        @logger.debug "authorization: [#{account_sid}, #{auth_token[0..2]}...#{auth_token[-3..-1]}]"
+        body_data = {
+          'To'   => address,
+          'From' => from,
+          'Body' => truncate(message, 159)
+        }
+
+        Flapjack.logger.debug "body_data: #{body_data.inspect}"
+        Flapjack.logger.debug "authorization: [#{account_sid}, #{auth_token[0..2]}...#{auth_token[-3..-1]}]"
+
+        req = Net::HTTP::Post.new(endpoint_path)
+        req.set_form_data(body_data)
+        req['Authorization'] = [account_sid, auth_token]
+
+        http_response = Net::HTTP.start(endpoint_host, 443, :use_ssl => true) do |http|
+          http.request(req)
+        end
 
-        http = EM::HttpRequest.new(endpoint).post(:body => body_data, :head => {'authorization' => [account_sid, auth_token]})
+        Flapjack.logger.debug "server response: #{http_response.inspect}"
 
-        @logger.debug "server response: #{http.response}"
+        status = http_response.code
 
-        status = (http.nil? || http.response_header.nil?) ? nil : http.response_header.status
-        if (status >= 200) && (status <= 206)
+        if (status.to_i >= 200) && (status.to_i <= 206)
           @sent += 1
-          alert.record_send_success!
-          @logger.debug "Sent SMS via Twilio, response status is #{status}, " +
-            "notification_id: #{notification_id}"
+          Flapjack.logger.info "Sent SMS via Twilio, response status is #{status}, " +
+            "alert id: #{alert.id}"
         else
-          @logger.error "Failed to send SMS via Twilio, response status is #{status}, " +
-            "notification_id: #{notification_id}"
+          Flapjack.logger.error "Failed to send SMS via Twilio, response status is #{status}, " +
+            "alert id: #{alert.id}"
         end
       rescue => e
-        @logger.error "Error generating or delivering sms to #{alert.address}: #{e.class}: #{e.message}"
-        @logger.error e.backtrace.join("\n")
+        Flapjack.logger.error "Error generating or delivering twilio sms to #{alert.medium.address}: #{e.class}: #{e.message}"
+        Flapjack.logger.error e.backtrace.join("\n")
         raise
       end
 

data/lib/flapjack/gateways/sms_twilio/alert.text.erb

@@ -1,6 +1,7 @@
+<% check = @alert.check -%>
 <% summary = @alert.summary -%>
-<%= @alert.type_sentence_case %>: '<%= @alert.check %>' on <%= @alert.entity -%>
-<% unless ['acknowledgement', 'test'].include?(@alert.notification_type) -%>
+<%= @alert.type_sentence_case %>: <%= "'#{check.name}'" -%>
+<% unless ['acknowledgement', 'test'].include?(@alert.type) -%>
  is <%= @alert.state_title_case -%>
 <% end -%>
  at <%= Time.at(@alert.time).strftime('%-d %b %H:%M') %><%= (summary.nil? || summary.empty?) ? '' : ", #{summary}" -%>

data/lib/flapjack/gateways/web.rb

@@ -3,16 +3,13 @@
 require 'chronic'
 require 'chronic_duration'
 require 'sinatra/base'
-require 'erb'
-require 'rack/fiber_pool'
-require 'json'
+require 'tilt/erb'
 require 'uri'
 
-require 'flapjack/rack_logger'
+require 'flapjack/gateways/web/middleware/request_timestamp'
+
+require 'flapjack-diner'
 
-require 'flapjack/data/contact'
-require 'flapjack/data/entity_check'
-require 'flapjack/redis_pool'
 require 'flapjack/utility'
 
 module Flapjack
@@ -21,67 +18,66 @@ module Flapjack
 
     class Web < Sinatra::Base
 
-      rescue_exception = Proc.new do |env, e|
-        if @config['show_exceptions'].is_a?(TrueClass)
-          # ensure the sinatra error page shows properly
-          request = Sinatra::Request.new(env)
-          printer = Sinatra::ShowExceptions.new(proc{ raise e })
-          s, h, b = printer.call(env)
-          [s, h, b]
-        else
-          @logger.error e.message
-          @logger.error e.backtrace.join("\n")
-          [503, {}, ""]
-        end
-      end
-      use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
+      set :root, File.dirname(__FILE__)
 
+      use Flapjack::Gateways::Web::Middleware::RequestTimestamp
       use Rack::MethodOverride
 
+      set :sessions, :true
+
+      set :raise_errors, false
+      set :protection, except: :path_traversal
+
+      set :views, settings.root + '/web/views'
+      set :public_folder, settings.root + '/web/public'
+
+      set :erb, :layout => 'layout.html'.to_sym
+
       class << self
         def start
-          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
+          Flapjack.logger.info "starting web - class"
 
-          @logger.info "starting web - class"
+          set :show_exceptions, false
+          @show_exceptions = Sinatra::ShowExceptions.new(self)
 
-          if accesslog = (@config && @config['access_log'])
-            if not File.directory?(File.dirname(accesslog))
-              puts "Parent directory for log file #{accesslog} doesn't exist"
-              puts "Exiting!"
-              exit
+          if access_log = (@config && @config['access_log'])
+            unless File.directory?(File.dirname(access_log))
+              raise "Parent directory for log file #{access_log} doesn't exist"
             end
 
-            access_logger = Flapjack::AsyncLogger.new(@config['access_log'])
-            use Flapjack::CommonLogger, access_logger
+            use Rack::CommonLogger, ::Logger.new(@config['access_log'])
           end
 
+          # session's only used for error message display, so
+          session_secret = @config['session_secret']
+
+          use Rack::Session::Cookie, :key => 'flapjack.session',
+                                     :path => '/',
+                                     :secret => session_secret || SecureRandom.hex(64)
+
           @api_url = @config['api_url']
-          if @api_url
-            if URI.regexp(['http', 'https']).match(@api_url).nil?
-              @logger.error "api_url is not a valid http or https URI (#{@api_url}), discarding"
-              @api_url = nil
-            end
-            unless @api_url.match(/^.*\/$/)
-              @logger.info "api_url must end with a trailing '/', setting to '#{@api_url}/'"
-              @api_url = "#{@api_url}/"
-            end
+          if @api_url.nil?
+            raise "'api_url' config must contain a Flapjack API instance address"
           end
 
-          unless @api_url
-            @logger.error "api_url is not configured, parts of the web interface will be broken"
+          uri = begin
+            URI(@api_url)
+          rescue URI::InvalidURIError
+            # TODO should we just log and re-raise the exception?
+            raise "'api_url' is not a valid URI (#{@api_url})"
           end
 
-          @base_url = @config['base_url']
-          unless @base_url
-            @logger.info "base_url is not configured, setting to '/'"
-            @base_url = '/'
+          unless ['http', 'https'].include?(uri.scheme)
+            raise "'api_url' is not a valid http or https URI (#{@api_url})"
           end
-
-          unless @base_url.match(/^.*\/$/)
-            @logger.warn "base_url must end with a trailing '/', setting to '#{@base_url}/'"
-            @base_url = "#{@base_url}/"
+          unless @api_url.match(/^.*\/$/)
+            Flapjack.logger.info "api_url must end with a trailing '/', setting to '#{@api_url}/'"
+            @api_url = "#{@api_url}/"
           end
 
+          Flapjack::Diner.base_uri(@api_url)
+          Flapjack::Diner.logger = Flapjack.logger
+
           # constants won't be exposed to eRb scope
           @default_logo_url = "img/flapjack-2013-notext-transparent-300-300.png"
           @logo_image_file  = nil
@@ -92,21 +88,17 @@ module Flapjack
               @logo_image_file = logo_image_path
               @logo_image_ext  = File.extname(logo_image_path)
             else
-              @logger.error "logo_image_path '#{logo_image_path}'' does not point to a valid file."
+              Flapjack.logger.error "logo_image_path '#{logo_image_path}'' does not point to a valid file."
             end
           end
 
-          @auto_refresh = @config['auto_refresh'].respond_to?('to_i') && @config['auto_refresh'].to_i > 0 ? @config['auto_refresh'].to_i : false
+          @auto_refresh = (@config['auto_refresh'].respond_to?('to_i') &&
+                           (@config['auto_refresh'].to_i > 0)) ? @config['auto_refresh'].to_i : false
         end
       end
 
       include Flapjack::Utility
 
-      set :protection, :except => :path_traversal
-
-      set :views, settings.root + '/web/views'
-      set :public_folder, settings.root + '/web/public'
-
       helpers do
         def h(text)
           ERB::Util.h(text)
@@ -117,28 +109,29 @@ module Flapjack
         end
 
         def include_active?(path)
-          request.path == "/#{path}" ? " class='active'" : ""
+          return '' unless request.path == "/#{path}"
+          " class='active'"
         end
 
         def charset_for_content_type(ct)
           charset = Encoding.default_external
-          charset.nil? ? ct : "#{ct}; charset=#{charset}"
+          charset.nil? ? ct : "#{ct}; charset=#{charset.name}"
         end
       end
 
-      def redis
-        self.class.instance_variable_get('@redis')
-      end
-
-      def logger
-        self.class.instance_variable_get('@logger')
+      ['config'].each do |class_inst_var|
+        define_method(class_inst_var.to_sym) do
+          self.class.instance_variable_get("@#{class_inst_var}")
+        end
       end
 
       before do
         content_type charset_for_content_type('text/html')
 
-        @api_url          = self.class.instance_variable_get('@api_url')
-        @base_url         = self.class.instance_variable_get('@base_url')
+        # needs to be done per-thread
+        Flapjack.configure_log('web', config['logger'])
+
+        @base_url         = "#{request.base_url}/"
         @default_logo_url = self.class.instance_variable_get('@default_logo_url')
         @logo_image_file  = self.class.instance_variable_get('@logo_image_file')
         @logo_image_ext   = self.class.instance_variable_get('@logo_image_ext')
@@ -146,14 +139,14 @@ module Flapjack
 
         input = nil
         query_string = (request.query_string.respond_to?(:length) &&
-                        request.query_string.length > 0) ? "?#{request.query_string}" : ""
-        if logger.debug?
+        request.query_string.length > 0) ? "?#{request.query_string}" : ""
+        if Flapjack.logger.debug?
           input = env['rack.input'].read
-          logger.debug("#{request.request_method} #{request.path_info}#{query_string} #{input}")
-        elsif logger.info?
+          Flapjack.logger.debug("#{request.request_method} #{request.path_info}#{query_string} #{input}")
+        elsif Flapjack.logger.info?
           input = env['rack.input'].read
           input_short = input.gsub(/\n/, '').gsub(/\s+/, ' ')
-          logger.info("#{request.request_method} #{request.path_info}#{query_string} #{input_short[0..80]}")
+          Flapjack.logger.info("#{request.request_method} #{request.path_info}#{query_string} #{input_short[0..80]}")
         end
         env['rack.input'].rewind unless input.nil?
       end
@@ -161,366 +154,435 @@ module Flapjack
       get '/img/branding.*' do
         halt(404) unless @logo_image_file && params[:splat].first.eql?(@logo_image_ext[1..-1])
         send_file(@logo_image_file)
-      end
+       end
 
       get '/' do
-        check_stats
-        entity_stats
+        @metrics = Flapjack::Diner.metrics
 
         erb 'index.html'.to_sym
       end
 
-      get '/checks_all' do
-        check_stats
-        @adjective = ''
-
-        checks_by_entity = Flapjack::Data::EntityCheck.find_current_names_by_entity(:redis => redis)
-        @states = checks_by_entity.keys.inject({}) {|result, entity_name|
-          Flapjack::Data::Entity.find_by_name(entity_name, :redis => redis, :create => true)
-          result[entity_name] = checks_by_entity[entity_name].sort.map {|check|
-            [check] + entity_check_state(entity_name, check)
-          }
-          result
-        }
-        @entities_sorted = checks_by_entity.keys.sort
+      get '/self_stats' do
+        @current_time = Time.now
 
-        erb 'checks.html'.to_sym
-      end
+        @api_url = self.class.instance_variable_get('@api_url')
 
-      get '/checks_failing' do
-        check_stats
-        @adjective = 'failing'
+        @metrics   = Flapjack::Diner.metrics
+        statistics = Flapjack::Diner.statistics
 
-        checks_by_entity = Flapjack::Data::EntityCheck.find_current_names_failing_by_entity(:redis => redis)
-        @states = checks_by_entity.keys.inject({}) {|result, entity|
-          result[entity] = checks_by_entity[entity].sort.map {|check|
-            [check] + entity_check_state(entity, check)
-          }
-          result
-        }
-        @entities_sorted = checks_by_entity.keys.sort
+        unless statistics.nil?
+          @executive_instances = statistics.each_with_object({}) do |stats, memo|
+            if 'global'.eql?(stats[:instance_name])
+              @global_stats = stats
+              next
+            end
+            boot_time =  Time.parse(stats[:created_at])
+            uptime = @current_time - boot_time
+            uptime_string = ChronicDuration.output(uptime, :format => :short,
+                              :keep_zero => true, :units => 2) || '0s'
 
-        erb 'checks.html'.to_sym
-      end
+            event_counters = {}
+            event_rates    = {}
 
-      get '/self_stats' do
-        logger.debug "calculating self_stats"
-        self_stats
-        logger.debug "calculating entity_stats"
-        entity_stats
-        logger.debug "calculating check_stats"
-        check_stats
+            [:all_events, :ok_events, :failure_events, :action_events,
+             :invalid_events].each do |evt|
 
-        erb 'self_stats.html'.to_sym
-      end
+              count               = stats[evt]
+              event_counters[evt] = count
+              event_rates[evt]    = (uptime > 0) ? (count.to_f / uptime).round : nil
+            end
 
-      get '/self_stats.json' do
-        self_stats
-        entity_stats
-        check_stats
-        json_data = {
-          'events_queued'       => @events_queued,
-          'all_entities'        => @count_current_entities,
-          'failing_entities'    => @count_failing_entities,
-          'all_checks'          => @count_current_checks,
-          'failing_checks'      => @count_failing_checks,
-          'processed_events' => {
-            'all_time' => {
-              'total'   => @event_counters['all'].to_i,
-              'ok'      => @event_counters['ok'].to_i,
-              'failure' => @event_counters['failure'].to_i,
-              'action'  => @event_counters['action'].to_i,
+            memo[stats[:instance_name]] = {
+              :uptime         => uptime,
+              :uptime_string  => uptime_string,
+              :event_counters => event_counters,
+              :event_rates    => event_rates
             }
-          },
-          'check_freshness'     => @current_checks_ages,
-          'total_keys'          => @dbsize,
-          'uptime'              => @uptime_string,
-          'boottime'            => @boot_time,
-          'current_time'        => Time.now,
-          'executive_instances' => @executive_instances,
-        }
-        Flapjack.dump_json(json_data)
-      end
+          end
+        end
 
-      get '/entities_all' do
-        redirect '/entities'
+        erb 'self_stats.html'.to_sym
       end
 
-      get '/entities' do
-        @entities = Flapjack::Data::Entity.all(:enabled => true, :redis => redis).map {|e| e.name}
+      get '/tags' do
+        opts = {}
+        @name = params[:name]
+        opts.update(:name => @name) unless @name.nil? || @name.empty?
+
+        @tags = Flapjack::Diner.tags(:filter => opts,
+          :page => (params[:page] || 1))
 
-        entity_stats(@entities)
-        @adjective = ''
+        unless @tags.nil? || @tags.empty?
+          @pagination = pagination_from_context(Flapjack::Diner.context)
+          unless @pagination.nil?
+            @links = create_pagination_links(@pagination[:page],
+              @pagination[:total_pages])
+          end
+        end
 
-        erb 'entities.html'.to_sym
+        erb 'tags.html'.to_sym
       end
 
-      get '/entities_decommissioned' do
-        entity_stats
-        @adjective = 'decommissioned'
-        @entities = Flapjack::Data::Entity.all(:enabled => false, :redis => redis)
+      get '/tags/:id' do
+        tag_id = params[:id]
 
-        erb 'entities.html'.to_sym
-      end
+        @tag = Flapjack::Diner.tags(tag_id, :include => 'checks')
+        err(404, "Could not find tag '#{tag_id}'") if @tag.nil?
 
-      get '/entities_failing' do
-        entity_stats
-        @adjective = 'failing'
-        @entities = Flapjack::Data::Entity.find_all_names_with_failing_checks(:redis => redis)
+        @checks = Flapjack::Diner.related(@tag, :checks)
 
-        erb 'entities.html'.to_sym
+        erb 'tag.html'.to_sym
       end
 
-      get '/entity/:entity' do
-        @entity = params[:entity]
-        entity_stats
-        @states = Flapjack::Data::EntityCheck.find_current_names_for_entity_name(@entity, :redis => redis).sort.map { |check|
-          [check] + entity_check_state(@entity, check)
-        }.sort_by {|parts| parts }
+      get '/checks' do
+        time = Time.now
+
+        opts = {}
+
+        @name = params[:name]
+        opts.update(:name => @name) unless @name.nil? || @name.empty?
+
+        @enabled = boolean_from_str(params[:enabled])
+        opts.update(:enabled => @enabled) unless @enabled.nil?
+
+        @failing = boolean_from_str(params[:failing])
+        opts.update(:failing => @failing) unless @failing.nil?
+
+        @checks = Flapjack::Diner.checks(:filter => opts,
+                    :page => (params[:page] || 1),
+                    :include => ['current_state', 'latest_notifications',
+                                 'current_scheduled_maintenances',
+                                 'current_unscheduled_maintenance'])
+
+        @states = {}
+
+        unless @checks.nil? || @checks.empty?
+          @pagination = pagination_from_context(Flapjack::Diner.context)
+          unless @pagination.nil?
+            @links = create_pagination_links(@pagination[:page],
+              @pagination[:total_pages])
+          end
 
-        erb 'entity.html'.to_sym
+          @states = @checks.each_with_object({}) do |check, memo|
+            memo[check[:id]] = check_state(check, time)
+          end
+        end
+
+        erb 'checks.html'.to_sym
       end
 
-      get '/check' do
+      get '/checks/:id' do
+        check_id  = params[:id]
 
-        @entity = params[:entity]
-        @check  = params[:check]
+        @current_time = DateTime.now
 
-        entity_check = get_entity_check(@entity, @check)
-        halt(404, "Could not find check '#{@entity}:#{@check}'") if entity_check.nil?
+        # contacts.media will also return contacts, per JSONAPI v1 relationships
+        @check = Flapjack::Diner.checks(check_id,
+                   :include => ['contacts.media', 'current_state',
+                                'latest_notifications',
+                                'current_scheduled_maintenances',
+                                'current_unscheduled_maintenance'])
 
-        last_change = entity_check.last_change
+        halt(404, "Could not find check '#{check_id}'") if @check.nil?
 
-        @check_state                = entity_check.state
-        @check_enabled              = entity_check.enabled?
-        @check_last_update          = entity_check.last_update
-        @check_last_change          = last_change
-        @check_summary              = entity_check.summary
-        @check_details              = entity_check.details
-        @check_perfdata             = entity_check.perfdata
+        @contacts = []
+        @media_by_contact_id = {}
 
-        @check_initial_failure_delay = entity_check.initial_failure_delay ||
-          Flapjack::DEFAULT_INITIAL_FAILURE_DELAY
-        @check_repeat_failure_delay  = entity_check.repeat_failure_delay  ||
-          Flapjack::DEFAULT_REPEAT_FAILURE_DELAY
+        @state = check_extra_state(@check, @current_time)
 
-        @check_initial_failure_delay_is_default = entity_check.initial_failure_delay ? false : true
-        @check_repeat_failure_delay_is_default  = entity_check.repeat_failure_delay  ? false : true
+        @contacts = Flapjack::Diner.related(@check, :contacts)
 
-        @last_notifications         = last_notification_data(entity_check)
+        @media_by_contact_id = @contacts.inject({}) do |memo, contact|
+          memo[contact[:id]] = Flapjack::Diner.related(contact, :media)
+          memo
+        end
+
+        # these two requests will only get first page of 20 records, which is what we want
+        state_links = Flapjack::Diner.check_link_states(check_id,
+          :include => 'states')
 
-        @scheduled_maintenances     = entity_check.maintenances(nil, nil, :scheduled => true)
-        @acknowledgement_id         = entity_check.failed? ? entity_check.ack_hash : nil
+        incl = Flapjack::Diner.included_data
+        unless incl.nil?
+          @state_changes = incl['state'].nil? ? [] : incl['state'].values
+        end
 
-        @current_scheduled_maintenance   = entity_check.current_maintenance(:scheduled => true)
-        @current_unscheduled_maintenance = entity_check.current_maintenance(:scheduled => false)
+        sm_links = Flapjack::Diner.check_link_scheduled_maintenances(check_id,
+          :include => 'scheduled_maintenances')
 
-        @contacts                   = entity_check.contacts
+        incl = Flapjack::Diner.included_data
+        unless incl.nil?
+          @scheduled_maintenances = incl['scheduled_maintenance'].nil? ? [] : incl['scheduled_maintenance'].values
+        end
 
-        @state_changes = entity_check.historical_states(nil, Time.now.to_i,
-                           :order => 'desc', :limit => 20)
+        @error = session[:error]; session.delete(:error)
 
         erb 'check.html'.to_sym
       end
 
-      post '/acknowledgements/:entity/:check' do
-        @entity             = params[:entity]
-        @check              = params[:check]
-        @summary            = params[:summary]
-        @acknowledgement_id = params[:acknowledgement_id]
+      post "/acknowledgements" do
+        summary  = params[:summary]
+        check_id = params[:check_id]
 
         dur = ChronicDuration.parse(params[:duration] || '')
-        @duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
+        duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
 
-        entity_check = get_entity_check(@entity, @check)
-        halt(404, "Could not find check '#{@entity}:#{@check}'") if entity_check.nil?
+        # FIXME create with known id, poll a few times and return
+        # success/failure in session -- or maybe some AJAX method to
+        # show success/failure?
 
-        ack = Flapjack::Data::Event.create_acknowledgement(
-          @entity, @check,
-          :summary => (@summary || ''),
-          :acknowledgement_id => @acknowledgement_id,
-          :duration => @duration,
-          :redis => redis)
+        Flapjack::Diner.create_acknowledgements(:summary => summary,
+          :duration => duration, :check => check_id)
+
+        err = Flapjack::Diner.error
+        unless err.nil?
+          session[:error] = "Could not create the acknowledgement: #{err}"
+        end
 
         redirect back
       end
 
-      # FIXME: there is bound to be a more idiomatic / restful way of doing this
-      # (probably using 'delete' or 'patch')
-      post '/end_unscheduled_maintenance/:entity/:check' do
-        @entity = params[:entity]
-        @check  = params[:check]
+      patch '/unscheduled_maintenances/:id' do
+        unscheduled_maintenance_id = params[:id]
 
-        entity_check = get_entity_check(@entity, @check)
-        halt(404, "Could not find check '#{@entity}:#{@check}'") if entity_check.nil?
+        Flapjack::Diner.update_unscheduled_maintenances(
+          :id => unscheduled_maintenance_id, :end_time => Time.now)
 
-        entity_check.end_unscheduled_maintenance(Time.now.to_i)
+        err = Flapjack::Diner.error
+        unless err.nil?
+          session[:error] = "Could not end unscheduled maintenance: #{err}"
+        end
 
         redirect back
       end
 
-      # create scheduled maintenance
-      post '/scheduled_maintenances/:entity/:check' do
-        start_time = Chronic.parse(params[:start_time]).to_i
-        halt(400, "Start time '#{params[:start_time]}' parsed to 0") if start_time == 0
+      post '/scheduled_maintenances' do
+        check_id  = params[:check_id]
+
+        start_time = Chronic.parse(params[:start_time])
+        raise ArgumentError, "start time parsed to nil" if start_time.nil?
         duration   = ChronicDuration.parse(params[:duration])
         summary    = params[:summary]
 
-        entity_check = get_entity_check(params[:entity], params[:check])
-        halt(404, "Could not find check '#{params[:entity]}:#{params[:check]}'") if entity_check.nil?
+        Flapjack::Diner.create_scheduled_maintenances(:summary => summary,
+          :start_time => start_time, :end_time => (start_time + duration),
+          :check => check_id)
+
+        err = Flapjack::Diner.error
+        unless err.nil?
+          Flapjack.logger.info "Could not create scheduled maintenance: #{err}"
+          session[:error] = "Could not create scheduled maintenance for the check."
+        end
 
-        entity_check.create_scheduled_maintenance(start_time, duration,
-                                                  :summary => summary)
         redirect back
       end
 
-      # delete a scheduled maintenance
-      delete '/scheduled_maintenances/:entity/:check' do
-        entity_check = get_entity_check(params[:entity], params[:check])
-        halt(404, "Could not find check '#{params[:entity]}:#{params[:check]}'") if entity_check.nil?
+      patch '/checks/:id' do
+        check_id = params[:id]
+
+        Flapjack::Diner.update_checks(:id => check_id, :enabled => false)
+
+        err = Flapjack::Diner.error
+        unless err.nil?
+          Flapjack.logger.info "Could not disable check: #{err}"
+          session[:error] = "Could not disable the check."
+        end
+
+        redirect '/'
+      end
+
+      patch '/scheduled_maintenances/:id' do
+        scheduled_maintenance_id = params[:id]
+
+        Flapjack::Diner.update_scheduled_maintenances({:id => scheduled_maintenance_id,
+          :end_time => Time.now})
+
+        err = Flapjack::Diner.error
+        unless err.nil?
+          Flapjack.logger.info "Could not end scheduled maintenance: #{err}"
+          session[:error] = "Could not end scheduled maintenance."
+        end
 
-        entity_check.end_scheduled_maintenance(params[:start_time].to_i)
         redirect back
       end
 
-      # delete a check (actually just disables it)
-      delete '/checks/:entity/:check' do
-        entity_check = get_entity_check(params[:entity], params[:check])
-        halt(404, "Could not find check '#{params[:entity]}:#{params[:check]}'") if entity_check.nil?
+      # FIXME should fail if its start time or end_time is in the past
+      # we'll allow the API to delete without fear or favour though
+      delete '/scheduled_maintenances/:id' do
+        scheduled_maintenance_id = params[:id]
+
+        Flapjack::Diner.delete_scheduled_maintenances(scheduled_maintenance_id)
+
+        err = Flapjack::Diner.error
+        unless err.nil?
+          Flapjack.logger.info "Could not delete scheduled maintenance: #{err}"
+          session[:error] = "Could not delete scheduled maintenance."
+        end
 
-        entity_check.disable!
         redirect back
       end
 
       get '/contacts' do
-        @contacts = Flapjack::Data::Contact.all(:redis => redis)
+        opts = {}
+        @name = params[:name]
+        opts.update(:name => @name) unless @name.nil?
+
+        @contacts = Flapjack::Diner.contacts(:page => params[:page] || 1,
+          :filter => opts, :sort => '+name')
+
+        unless @contacts.nil?
+          @pagination = pagination_from_context(Flapjack::Diner.context)
+          unless @pagination.nil?
+            @links = create_pagination_links(@pagination[:page],
+              @pagination[:total_pages])
+          end
+        end
 
         erb 'contacts.html'.to_sym
       end
 
-      get '/edit_contacts' do
-        erb 'edit_contacts.html'.to_sym
-      end
-
-      get "/contacts/:contact" do
-        contact_id = params[:contact]
-        halt(404, "No contact id") if contact_id.nil?
+      get "/contacts/:id" do
+        contact_id = params[:id]
 
-        @contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis)
+        @contact = Flapjack::Diner.contacts(contact_id,
+          :include => ['checks', 'media.alerting_checks',
+                       'rules.tags', 'rules.media'])
         halt(404, "Could not find contact '#{contact_id}'") if @contact.nil?
 
-        if @contact.media.has_key?('pagerduty')
-          @pagerduty_credentials = @contact.pagerduty_credentials
+        @checks = []
+        @media = []
+        @rules = []
+
+        @alerting_checks_by_media_id = {}
+
+        @tags_by_rule_id  = {}
+        @media_by_rule_id = {}
+
+        @checks = Flapjack::Diner.related(@contact, :checks)
+        @media = Flapjack::Diner.related(@contact, :media)
+
+        unless @media.nil? || @media.empty?
+          @alerting_checks_by_media_id = @media.inject({}) do |memo, medium|
+            memo[medium[:id]] = Flapjack::Diner.related(medium, :alerting_checks)
+            memo
+          end
         end
 
-        # FIXME: intersect with current checks, or push down to Contact.entities
-        @entities_and_checks = @contact.entities(:checks => true).sort_by {|ec|
-          ec[:entity].name
-        }
+        @rules = Flapjack::Diner.related(@contact, :rules)
+
+        unless @rules.nil? || @rules.empty?
+          @tags_by_rule_id = @rules.inject({}) do |memo, rule|
+            memo[rule[:id]] = Flapjack::Diner.related(rule, :tags)
+            memo
+          end
+
+          @media_by_rule_id = @rules.inject({}) do |memo, rule|
+            memo[rule[:id]] = Flapjack::Diner.related(rule, :media)
+            memo
+          end
+        end
 
         erb 'contact.html'.to_sym
       end
 
-    private
+      error do
+        e = env['sinatra.error']
+        # trace = e.backtrace.join("\n")
+        # puts trace
 
-      def get_entity_check(entity, check)
-        entity_obj = (entity && entity.length > 0) ?
-          Flapjack::Data::Entity.find_by_name(entity, :redis => redis) : nil
-        return if entity_obj.nil? || (check.nil? || check.length == 0)
-        Flapjack::Data::EntityCheck.for_entity(entity_obj, check, :redis => redis)
+        # Rack::CommonLogger doesn't log requests which result in exceptions.
+        # If you want something done properly, do it yourself...
+        access_log = self.class.instance_variable_get('@middleware').detect {|mw|
+          mw.first.is_a?(::Rack::CommonLogger)
+        }
+        unless access_log.nil?
+          access_log.first.send(:log, status_code,
+            ::Rack::Utils::HeaderHash.new(headers), msg,
+            env['request_timestamp'])
+        end
+        self.class.instance_variable_get('@show_exceptions').pretty(env, e)
       end
 
-      def entity_check_state(entity_name, check)
-        entity = Flapjack::Data::Entity.find_by_name(entity_name,
-          :redis => redis)
-        return ['-', '-', 'never', 'never', false, false, 'never'] if entity.nil?
-        entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
-          check, :redis => redis)
-        summary = entity_check.summary
-        summary = summary[0..76] + '...' unless (summary.nil? || (summary.length < 81))
-        latest_notif =
-          {:problem         => entity_check.last_notification_for_state(:problem)[:timestamp],
-           :recovery        => entity_check.last_notification_for_state(:recovery)[:timestamp],
-           :acknowledgement => entity_check.last_notification_for_state(:acknowledgement)[:timestamp]
-          }.max_by {|n| n[1] || 0}
-
-        lc = entity_check.last_change
-        last_change   = lc ? (ChronicDuration.output(Time.now.to_i - lc.to_i,
-                               :format => :short, :keep_zero => true, :units => 2) || '0s') : 'never'
-
-        lu = entity_check.last_update
-        last_update   = lu ? (ChronicDuration.output(Time.now.to_i - lu.to_i,
-                               :format => :short, :keep_zero => true, :units => 2) || '0s') : 'never'
-
-        ln = latest_notif[1]
-        last_notified = ln ? (ChronicDuration.output(Time.now.to_i - ln.to_i,
-                               :format => :short, :keep_zero => true, :units => 2) || '0s') + ", #{latest_notif[0]}" : 'never'
-
-        [(entity_check.state       || '-'),
-         (summary                  || '-'),
-         last_change,
-         last_update,
-         entity_check.in_unscheduled_maintenance?,
-         entity_check.in_scheduled_maintenance?,
-         last_notified
-        ]
-      end
+    private
 
-      def self_stats
-        @fqdn    = `/bin/hostname -f`.chomp
-        @pid     = Process.pid
-
-        @dbsize              = redis.dbsize
-        @executive_instances = redis.keys("executive_instance:*").inject({}) do |memo, i|
-          instance_id    = i.match(/executive_instance:(.*)/)[1]
-          boot_time      = redis.hget(i, 'boot_time').to_i
-          uptime         = Time.now.to_i - boot_time
-          uptime_string  = (ChronicDuration.output(uptime, :format => :short, :keep_zero => true, :units => 2) || '0s')
-          event_counters = redis.hgetall("event_counters:#{instance_id}")
-          event_rates    = event_counters.inject({}) do |er, ec|
-            er[ec[0]] = uptime && uptime > 0 ? (ec[1].to_f / uptime).round : nil
-            er
+      def check_state(check, time)
+        current_state = Flapjack::Diner.related(check, :current_state)
+
+        last_changed = if current_state.nil? || current_state[:created_at].nil?
+          nil
+        else
+          begin
+            DateTime.parse(current_state[:created_at])
+          rescue ArgumentError
+            Flapjack.logger.warn("error parsing check state :created_at ( #{current_state.inspect} )")
           end
-          memo[instance_id] = {
-            'boot_time'      => boot_time,
-            'uptime'         => uptime,
-            'uptime_string'  => uptime_string,
-            'event_counters' => event_counters,
-            'event_rates'    => event_rates
-          }
-          memo
         end
-        @event_counters = redis.hgetall('event_counters')
-        @events_queued  = redis.llen('events')
-        @current_checks_ages = Flapjack::Data::EntityCheck.find_all_split_by_freshness([0, 60, 300, 900, 3600], {:redis => redis, :logger => logger, :counts => true } )
-      end
 
-      def entity_stats(entities = nil)
-        @count_current_entities  = (entities || Flapjack::Data::Entity.all(:enabled => true, :redis => redis)).length
-        @count_failing_entities  = Flapjack::Data::Entity.find_all_names_with_failing_checks(:redis => redis).length
-      end
+        last_updated = if current_state.nil? || current_state[:updated_at].nil?
+          nil
+        else
+          begin
+            DateTime.parse(current_state[:updated_at])
+          rescue ArgumentError
+            Flapjack.logger.warn("error parsing check state :updated_at ( #{current_state.inspect} )")
+          end
+        end
+
+        latest_notifications = Flapjack::Diner.related(check, :latest_notifications)
 
-      def check_stats
-        @count_current_checks    = Flapjack::Data::EntityCheck.count_current(:redis => redis)
-        @count_failing_checks    = Flapjack::Data::EntityCheck.count_current_failing(:redis => redis)
+        current_scheduled_maintenances = Flapjack::Diner.related(check, :current_scheduled_maintenances)
+        current_scheduled_maintenance = current_scheduled_maintenances.max_by do |sm|
+          begin
+            DateTime.parse(sm[:end_time]).to_i
+          rescue ArgumentError
+            Flapjack.logger.warn "Couldn't parse time from current_scheduled_maintenances"
+            -1
+          end
+        end
+
+        in_scheduled_maintenance = !current_scheduled_maintenance.nil?
+
+        current_unscheduled_maintenance = Flapjack::Diner.related(check, :current_unscheduled_maintenance)
+        in_unscheduled_maintenance = !current_unscheduled_maintenance.nil?
+
+        {
+          :condition     => current_state.nil? ? '-' : current_state[:condition],
+          :summary       => current_state.nil? ? '-' : current_state[:summary],
+          :latest_notifications => (latest_notifications || []),
+          :last_changed  => last_changed,
+          :last_updated  => last_updated,
+          :in_scheduled_maintenance => in_scheduled_maintenance,
+          :in_unscheduled_maintenance => in_unscheduled_maintenance
+        }
       end
 
-      def last_notification_data(entity_check)
-        last_notifications = entity_check.last_notifications_of_each_type
-        [:critical, :warning, :unknown, :recovery, :acknowledgement].inject({}) do |memo, type|
-          if last_notifications[type] && last_notifications[type][:timestamp]
-            t = Time.at(last_notifications[type][:timestamp])
-            memo[type] = {:time => t.to_s,
-                          :relative => relative_time_ago(t) + " ago",
-                          :summary => last_notifications[type][:summary]}
+      def check_extra_state(check, time)
+        state = check_state(check, time)
+
+        current_state = Flapjack::Diner.related(check, :current_state)
+
+        current_scheduled_maintenances = Flapjack::Diner.related(check, :current_scheduled_maintenances)
+        current_scheduled_maintenance = current_scheduled_maintenances.max_by do |sm|
+          begin
+            DateTime.parse(sm[:end_time]).to_i
+          rescue ArgumentError
+            Flapjack.logger.warn "Couldn't parse time from current_scheduled_maintenances"
+            -1
           end
-          memo
         end
+
+        current_unscheduled_maintenance = Flapjack::Diner.related(check, :current_unscheduled_maintenance)
+
+        state.merge(
+          :details       => current_state.nil? ? '-' : current_state[:details],
+          :perfdata      => current_state.nil? ? '-' : current_state[:perfdata],
+          :current_scheduled_maintenances => (current_scheduled_maintenances || []),
+          :current_scheduled_maintenance => current_scheduled_maintenance,
+          :current_unscheduled_maintenance => current_unscheduled_maintenance,
+        )
       end
 
-      def require_css(*css)
-        @required_css ||= []
-        @required_css += css
+      def pagination_from_context(context)
+        ((context || {})[:meta] || {})[:pagination]
       end
 
       def require_js(*js)
@@ -529,24 +591,24 @@ module Flapjack
         @required_js.uniq!
       end
 
+      def require_css(*css)
+        @required_css ||= []
+        @required_css += css
+        @required_css.uniq!
+      end
+
       def include_required_js
-        if @required_js
-          @required_js.map { |filename|
-            "<script type='text/javascript' src='#{link_to("js/#{filename}.js")}'></script>"
-          }.join("\n    ")
-        else
-          ""
-        end
+        return "" if @required_js.nil?
+        @required_js.map { |filename|
+          "<script type='text/javascript' src='#{link_to("js/#{filename}.js")}'></script>"
+        }.join("\n    ")
       end
 
       def include_required_css
-        if @required_css
-          @required_css.map { |filename|
-            %(<link rel="stylesheet" href="#{link_to("css/#{filename}.css")}" media="screen">)
-          }.join("\n    ")
-        else
-          ""
-        end
+        return "" if @required_css.nil?
+        @required_css.map { |filename|
+          %(<link rel="stylesheet" href="#{link_to("css/#{filename}.css")}" media="screen">)
+        }.join("\n    ")
       end
 
       # from http://gist.github.com/98310
@@ -573,7 +635,37 @@ module Flapjack
       end
 
       def include_page_title
-        @page_title ? "#{@page_title} | Flapjack" : "Flapjack"
+        if instance_variable_defined?('@page_title') && !@page_title.nil?
+          return "#{@page_title} | Flapjack"
+        end
+        "Flapjack"
+      end
+
+      def boolean_from_str(str)
+        case str
+        when '0', 'f', 'false', 'n', 'no'
+          false
+        when '1', 't', 'true', 'y', 'yes'
+          true
+        end
+      end
+
+      def create_pagination_links(page, total_pages)
+        pages = {}
+        pages[:first] = 1
+        pages[:prev]  = page - 1 if (page > 1)
+        pages[:next]  = page + 1 if page < total_pages
+        pages[:last]  = total_pages
+
+        url_without_params = request.url.split('?').first
+
+        links = {}
+        pages.each do |key, value|
+          page_params = {'page' => value }
+          new_params = request.params.merge(page_params)
+          links[key] = "#{url_without_params}?#{new_params.to_query}"
+        end
+        links
       end
     end
   end