flapjack 1.0.0rc3 → 1.0.0rc5

data/lib/flapjack/data/entity_check.rb

@@ -7,6 +7,8 @@ require 'flapjack/patches'
 require 'flapjack/data/contact'
 require 'flapjack/data/event'
 require 'flapjack/data/entity'
+#FIXME: Require chronic_duration in the correct place
+require 'chronic_duration'
 
 # TODO might want to split the class methods out to a separate class, DAO pattern
 # ( http://en.wikipedia.org/wiki/Data_access_object ).
@@ -61,17 +63,17 @@ module Flapjack
         self.new(entity, check, :logger => logger, :redis => redis)
       end
 
-      def self.find_all_for_entity_name(entity_name, options = {})
+      def self.find_current_for_entity_name(entity_name, options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         redis.zrange("current_checks:#{entity_name}", 0, -1)
       end
 
-      def self.find_all(options = {})
+      def self.find_current(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        self.conflate_to_keys(self.find_all_by_entity(:redis => redis))
+        self.conflate_to_keys(self.find_current_by_entity(:redis => redis))
       end
 
-      def self.find_all_by_entity(options = {})
+      def self.find_current_by_entity(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         d = {}
         redis.zrange("current_entities", 0, -1).each {|entity|
@@ -80,19 +82,19 @@ module Flapjack
         d
       end
 
-      def self.count_all(options = {})
+      def self.count_current(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         redis.zrange("current_entities", 0, -1).inject(0) {|memo, entity|
           memo + redis.zcount("current_checks:#{entity}", '-inf', '+inf')
         }
       end
 
-      def self.find_all_failing(options = {})
+      def self.find_current_failing(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
-        self.conflate_to_keys(self.find_all_failing_by_entity(:redis => redis))
+        self.conflate_to_keys(self.find_current_failing_by_entity(:redis => redis))
       end
 
-      def self.find_all_failing_by_entity(options = {})
+      def self.find_current_failing_by_entity(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         redis.zrange("failed_checks", 0, -1).inject({}) do |memo, key|
           entity, check = key.split(':', 2)
@@ -104,7 +106,7 @@ module Flapjack
         end
       end
 
-      def self.count_all_failing(options = {})
+      def self.count_current_failing(options = {})
         raise "Redis connection not set" unless redis = options[:redis]
         redis.zrange("failed_checks", 0, -1).count do |key|
           entity, check = key.split(':', 2)
@@ -132,6 +134,201 @@ module Flapjack
         result
       end
 
+      def self.find_maintenance(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        type = options[:type]
+        keys = redis.keys("*:#{type}_maintenances")
+        keys.flat_map { |k|
+          entity = k.split(':')[0]
+          check = k.split(':')[1]
+          ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => redis)
+
+          # Only return entries which match what was passed in
+          case
+          when options[:state] && options[:state] != ec.state
+            nil
+          when options[:entity] && !Regexp.new(options[:entity]).match(entity)
+            nil
+          when options[:check] && !Regexp.new(options[:check]).match(check)
+            nil
+          else
+            windows = ec.maintenances(nil, nil, type.to_sym => true)
+            windows.map { |window|
+              entry = { :entity => entity,
+                        :check => check,
+                        :state => ec.state
+              }
+              if (options[:reason].nil? || Regexp.new(options[:reason]).match(window[:summary])) &&
+                check_maintenance_timestamp(options[:started], window[:start_time]) &&
+                check_maintenance_timestamp(options[:finishing], window[:end_time]) &&
+                check_maintenance_interval(options[:duration], window[:duration])
+                entry.merge!(window)
+              end
+            }.compact
+          end
+        }.compact
+      end
+
+      def self.delete_maintenance(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        entries = find_maintenance(options)
+        # Try to delete all entries passed in, but return false if any entries failed
+        errors = {}
+        entries.each do |entry|
+          identifier = "#{entry[:entity]}:#{entry[:check]}:#{entry[:start_time]}"
+          if entry[:end_time] < Time.now.to_i
+            errors[identifier] = "Maintenance can't be deleted as it finished in the past"
+          else
+            entity = entry[:entity]
+            check = entry[:check]
+
+            ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => redis)
+            success = case options[:type]
+            when 'scheduled'
+              ec.end_scheduled_maintenance(entry[:start_time])
+            when 'unscheduled'
+              ec.end_unscheduled_maintenance(entry[:end_time])
+            end
+            errors[identifier] = "The following entry failed to delete: #{entry}" unless success
+          end
+        end
+        errors
+      end
+
+      def self.create_maintenance(options = {})
+        raise "Redis connection not set" unless redis = options[:redis]
+        errors = {}
+        entities = options[:entity].is_a?(String) ? options[:entity].split(',') : options[:entity]
+        checks = options[:check].is_a?(String) ? options[:check].split(',') : options[:check]
+        entities.each do |entity|
+          # Create the entity if it doesn't exist, so we can schedule maintenance against it
+          Flapjack::Data::Entity.find_by_name(entity, :redis => redis, :create => true)
+          checks.each do |check|
+            ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => redis)
+            started = Chronic.parse(options[:started]).to_i
+            duration = ChronicDuration.parse(options[:duration]).to_i
+            raise "Failed to parse start time #{options[:started]}" if started == 0
+            raise"Failed to parse duration #{options[:duration]}" if duration == 0
+
+            success = case options[:type]
+            when 'scheduled'
+              ec.create_scheduled_maintenance(started, duration, :summary => options[:reason])
+            when 'unscheduled'
+              ec.create_unscheduled_maintenance(started, duration, :summary => options[:reason])
+            end
+            identifier = "#{entity}:#{check}:#{started}"
+            errors[identifier] = "The following check failed to create: #{identifier}" unless success
+          end
+        end
+        errors
+      end
+
+
+      def self.check_maintenance_interval(input, maintenance_duration)
+        # If no duration was specified, give back all results
+        return true unless input
+        inp = input.downcase
+
+        if inp.start_with?('between')
+          # Between 3 hours and 4 hours translates to more than 3 hours, less than 4 hours
+          first, last = inp.match(/between (.*) and (.*)/).captures
+          suffix = last.match(/\w (.*)/) ? last.match(/\w (.*)/).captures.first : ''
+
+          # If the first duration only contains only a single word, the unit is
+          # most likely directly after the first word of the the second duration
+          # eg between 3 and 4 hours
+          first = "#{first} #{suffix}" unless / /.match(first)
+          raise "Failed to parse #{first}" unless ChronicDuration.parse(first)
+          raise "Failed to parse #{last}" unless ChronicDuration.parse(last)
+
+          (first, last = last, first) if ChronicDuration.parse(first) > ChronicDuration.parse(last)
+          return check_maintenance_interval("more than #{first}", maintenance_duration) && check_maintenance_interval("less than #{last}", maintenance_duration)
+        end
+
+        # ChronicDuration can't parse timestamps for strings starting with before or after.
+        # Strip the before or after for the conversion only, but use it for the comparison later
+        ctime = inp.gsub(/^(more than|less than|before|after)/, '')
+        input_duration = ChronicDuration.parse(ctime, :keep_zero => true)
+
+        raise "Failed to parse time: #{input}" if input_duration.nil?
+
+        case inp
+        when /^(less than|before)/
+          maintenance_duration < input_duration
+        when /^(more than|after)/
+          maintenance_duration > input_duration
+        else
+          maintenance_duration == input_duration
+        end
+      end
+
+      def self.check_maintenance_timestamp(input, maintenance_timestamp)
+        # If no time was specified, give back all results
+        return true unless input
+        inp = input.downcase
+
+        # Chronic can't parse timestamps for strings starting with before, after or in some cases, on.
+        # Strip the before or after for the conversion only, but use it for the comparison later
+        ctime = inp.gsub(/^(on|before|after)/, '')
+
+        base_time = Time.now
+
+        case inp
+        # Between 3 and 4 hours ago translates to more than 3 hours ago, less than 4 hours ago
+        when /^between/
+          first, last = inp.match(/between (.*) and (.*)/).captures
+
+          # If the first time only contains only a single word, the unit (and past/future) is
+          # most likely directly after the first word of the the second time
+          # eg between 3 and 4 hours ago
+          suffix = last.match(/\w (.*)/) ? last.match(/\w (.*)/).captures.first : ''
+          first = "#{first} #{suffix}" unless / /.match(first)
+
+          first += ' from now' unless Chronic.parse(first, :now => base_time)
+          last += ' from now' unless Chronic.parse(last, :now => base_time)
+          raise "Failed to parse #{first}" unless ChronicDuration.parse(first)
+          raise "Failed to parse #{last}" unless ChronicDuration.parse(last)
+
+          (first, last = last, first) if Chronic.parse(first, :now => base_time) > Chronic.parse(last, :now => base_time)
+          (check_maintenance_timestamp("after #{first}", maintenance_timestamp) &&
+            check_maintenance_timestamp("before #{last}", maintenance_timestamp))
+        # On 1/1/15.  We use Chronic to work out the minimum and maximum timestamp, and use the same behaviour as between.
+        when /^on/
+          first = Chronic.parse(ctime, :guess => false, :now => base_time).first
+          last = Chronic.parse(ctime, :guess => false, :now => base_time).last
+          (check_maintenance_timestamp("after #{first}", maintenance_timestamp) &&
+            check_maintenance_timestamp("before #{last}", maintenance_timestamp))
+        else
+          # We assume timestamps are rooted against the current time.
+          # Chronic doesn't always handle this correctly, so we need to handhold it a little
+          input_timestamp = Chronic.parse(ctime, :keep_zero => true, :now => base_time).to_i
+          input_timestamp = Chronic.parse(ctime + ' from now', :keep_zero => true, :now => base_time).to_i if input_timestamp == 0
+
+          raise "Failed to parse time: #{input}" if input_timestamp == 0
+
+          case inp
+          when /^less than/
+            if input_timestamp < base_time.to_i
+              maintenance_timestamp > input_timestamp
+            else
+              maintenance_timestamp < input_timestamp
+            end
+          when /^more than/
+            # FIXME: and here is the race condition. input timestamp could be in the previous second
+            # to Time.now due to code execution time:
+            if input_timestamp < base_time.to_i
+              maintenance_timestamp < input_timestamp
+            else
+              maintenance_timestamp > input_timestamp
+            end
+          when /^before/
+            maintenance_timestamp < input_timestamp
+          when /^after/
+            maintenance_timestamp > input_timestamp
+          end
+        end
+      end
+
       def self.in_unscheduled_maintenance_for_event_id?(event_id, options)
         raise "Redis connection not set" unless redis = options[:redis]
         redis.exists("#{event_id}:unscheduled_maintenance")
@@ -184,10 +381,9 @@ module Flapjack
 
         checks = []
         # get all the current checks, with last update time
-        Flapjack::Data::Entity.find_all_current(:redis => redis).each do |entity|
-          redis.zrange("current_checks:#{entity}", 0, -1, {:withscores => true}).each do |check|
-            check[0] = "#{entity}:#{check[0]}"
-            checks << check
+        Flapjack::Data::Entity.all(:enabled => true, :redis => redis).each do |entity|
+          redis.zrange("current_checks:#{entity}", 0, -1, :withscores => true).each do |check, score|
+            checks << ["#{entity}:#{check}", score]
           end
         end
 
@@ -270,10 +466,11 @@ module Flapjack
         if (um_start = @redis.get("#{@key}:unscheduled_maintenance"))
           duration = end_time - um_start.to_i
           @logger.debug("ending unscheduled downtime for #{@key} at #{Time.at(end_time).to_s}") if @logger
-          @redis.del("#{@key}:unscheduled_maintenance")
           @redis.zadd("#{@key}:unscheduled_maintenances", duration, um_start) # updates existing UM 'score'
+          @redis.del("#{@key}:unscheduled_maintenance") == 1
         else
           @logger.debug("end_unscheduled_maintenance called for #{@key} but none found") if @logger
+          true
         end
       end
 
@@ -392,6 +589,7 @@ module Flapjack
           end
 
           # Retain event data for entity:check pair
+          # NB (appending to tail as far as Redis is concerned)
           @redis.rpush("#{@key}:states", timestamp)
           @redis.set("#{@key}:#{timestamp}:state", new_state)
           @redis.set("#{@key}:#{timestamp}:summary", summary) if summary

data/lib/flapjack/data/event.rb

@@ -124,7 +124,7 @@ module Flapjack
           if parsed.is_a?(Hash)
             errors = validation_errors_for_hash(parsed, opts)
           else
-            errors << "Event must be a JSON hash, see https://github.com/flapjack/flapjack/wiki/DATA_STRUCTURES#event-queue"
+            errors << "Event must be a JSON hash, see http://flapjack.io/docs/1.0/development/DATA_STRUCTURES#event-queue"
           end
           return parsed if errors.empty?
         end

data/lib/flapjack/gateways/aws_sns.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require 'em-synchrony'
+require 'em-synchrony/em-http'
+require 'active_support/inflector'
+
+require 'flapjack/data/alert'
+require 'flapjack/utility'
+
+module Flapjack
+  module Gateways
+    class AwsSns
+
+      SNS_DEFAULT_REGION_NAME = 'us-east-1'
+
+      class << self
+
+        include Flapjack::Utility
+
+        def start
+          @sent = 0
+        end
+
+        def perform(contents)
+          @logger.debug "Received a notification: #{contents.inspect}"
+          alert = Flapjack::Data::Alert.new(contents, :logger => @logger)
+
+          region_name = @config["region_name"] || SNS_DEFAULT_REGION_NAME
+          hostname = "sns.#{region_name}.amazonaws.com"
+          endpoint = "http://#{hostname}/"
+          access_key = @config["access_key"]
+          secret_key = @config["secret_key"]
+          timestamp = @config["timestamp"] || DateTime.now.iso8601
+
+          address         = alert.address
+          notification_id = alert.notification_id
+          message_type    = alert.rollup ? 'rollup' : 'alert'
+
+          my_dir = File.dirname(__FILE__)
+          sms_template_path = case
+          when @config.has_key?('templates') && @config['templates']["#{message_type}.text"]
+            @config['templates']["#{message_type}.text"]
+          else
+            my_dir + "/aws_sns/#{message_type}.text.erb"
+          end
+          sms_template = ERB.new(File.read(sms_template_path), nil, '-')
+
+          @alert  = alert
+          bnd     = binding
+
+          begin
+            message = sms_template.result(bnd).chomp
+          rescue => e
+            @logger.error "Error while excuting the ERB for an sms: " +
+              "ERB being executed: #{sms_template_path}"
+            raise
+          end
+
+          if @config.nil? || (@config.respond_to?(:empty?) && @config.empty?)
+            @logger.error "AWS SNS config is missing"
+            return
+          end
+
+          errors = []
+
+          [[address, "AWS SNS topic ARN is missing"],
+           [access_key, "AWS SNS access key is missing"],
+           [secret_key,  "AWS SNS secret key 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?)
+            errors << val_err.last
+          end
+
+          unless errors.empty?
+            errors.each {|err| @logger.error err }
+            return
+          end
+
+
+          query = {'Subject'          => message,
+                   'TopicArn'         => address,
+                   'Message'          => message,
+                   'Action'           => 'Publish',
+                   'SignatureVersion' => 2,
+                   'SignatureMethod'  => 'HmacSHA256',
+                   'Timestamp'        => timestamp,
+                   'AWSAccessKeyId'   => access_key}
+
+          string_to_sign = string_to_sign('POST', hostname, "/", query)
+
+          query['Signature'] = get_signature(secret_key, string_to_sign)
+
+          http = EM::HttpRequest.new(endpoint).post(:query => query)
+
+          @logger.debug "server response: #{http.response}"
+
+          status = (http.nil? || http.response_header.nil?) ? nil : http.response_header.status
+          if (status >= 200) && (status <= 206)
+            @sent += 1
+            alert.record_send_success!
+            @logger.debug "Sent notification via SNS, response status is #{status}, " +
+              "notification_id: #{notification_id}"
+          else
+            @logger.error "Failed to send notification via SNS, response status is #{status}, " +
+              "notification_id: #{notification_id}"
+          end
+        rescue => e
+          @logger.error "Error generating or delivering notification to #{address}: #{e.class}: #{e.message}"
+          @logger.error e.backtrace.join("\n")
+          raise
+        end
+
+        def get_signature(secret_key, string_to_sign)
+          signature = OpenSSL::HMAC.digest('sha256', secret_key, string_to_sign)
+
+          Base64.encode64(signature).strip
+        end
+
+        def string_to_sign(method, host, uri, query)
+          query = query.sort_by { |key, value| key }
+
+          [method.upcase,
+           host.downcase,
+           uri,
+           URI.encode_www_form(query)
+          ].join("\n")
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,5 @@
+<%= @alert.type_sentence_case %>: '<%= @alert.check %>' on <%= @alert.entity -%>
+<% unless ['acknowledgement', 'test'].include?(@alert.notification_type) -%>
+ is <%= @alert.state_title_case -%>
+<% end -%>
+ at <%= Time.at(@alert.time).strftime('%-d %b %H:%M') %>, <%= @alert.summary -%>

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

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