flapjack 0.7.2 → 0.7.3

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## Flapjack Changelog
 
+# 0.7.3 - 2013-05-14
+- Bug: Web and api gateways have configuable http timeout gh-170 (@jessereynolds)
+- Bug: Support POSTs to API larger than ~112 KB gh-169 (@jessereynolds)
+- Bug: Validate notification rules before adding, updating gh-146 (@ali-graham)
+- Bug: Web UI very slow with large number of keys gh-164 (@jessereynolds)
+- Bug: crash in executive should exit flapjack gh-143 (@ali-graham)
+
 # 0.7.2 - 2013-05-06
 - Feature: executive instance keys now expire after 7 days, touched every event gh-111 (@jessereynolds)
 - Feature: slightly less sucky looking web UI, also now includes entity listing screens (@jessereynolds)

data/etc/flapjack_config.yaml.example

@@ -80,12 +80,14 @@ development:
     web:
       enabled: yes
       port: 5080
+      timeout: 300
       access_log: "log/web_access.log"
       logger:
         level: INFO
     api:
       enabled: yes
       port: 5081
+      timeout: 300
       access_log: "log/api_access.log"
       logger:
         level: INFO

data/features/notification_rules.feature

@@ -3,9 +3,9 @@ Feature: Notification rules on a per contact basis
 
   Background:
     Given the following users exist:
-      | id  | first_name | last_name | email             | sms          |
-      | 1   | Malak      | Al-Musawi | malak@example.com | +61400000001 |
-      | 2   | Imani      | Farooq    | imani@example.com | +61400000002 |
+      | id  | first_name | last_name | email             | sms          | timezone         |
+      | 1   | Malak      | Al-Musawi | malak@example.com | +61400000001 | Asia/Baghdad     |
+      | 2   | Imani      | Farooq    | imani@example.com | +61400000002 | Europe/Moscow    |
 
     And the following entities exist:
       | id  | name | contacts |
@@ -25,7 +25,7 @@ Feature: Notification rules on a per contact basis
 
   @time_restrictions @time
   Scenario: Alerts only during specified time restrictions
-    Given the timezone is America/New_York
+    Given the timezone is Asia/Baghdad
     And   the time is February 1 2013 6:59
     And   the check is check 'ping' on entity 'foo'
     And   the check is in an ok state

data/features/steps/events_steps.rb

@@ -111,6 +111,19 @@ def submit_acknowledgement(entity, check)
   submit_event(event)
 end
 
+def icecube_schedule_to_time_restriction(sched, time_zone)
+  tr = sched.to_hash
+  tr[:start_time] = time_zone.utc_to_local(tr[:start_date][:time]).strftime "%Y-%m-%d %H:%M:%S"
+  tr[:end_time]   = time_zone.utc_to_local(tr[:end_time][:time]).strftime "%Y-%m-%d %H:%M:%S"
+
+  # rewrite IceCube::WeeklyRule to Weekly, etc
+  tr[:rrules].each {|rrule|
+    rrule[:rule_type] = /^.*\:\:(.*)Rule$/.match(rrule[:rule_type])[1]
+  }
+
+  tr
+end
+
 Given /^an entity '([\w\.\-]+)' exists$/ do |entity|
   Flapjack::Data::Entity.add({'id'       => '5000',
                               'name'     => entity},
@@ -240,7 +253,7 @@ Given /^the following users exist:$/ do |contacts|
                                  'last_name'  => contact['last_name'],
                                  'email'      => contact['email'],
                                  'media'      => media},
-                                :redis => @redis )
+                                :redis => @redis ).timezone = contact['timezone']
   end
 end
 
@@ -258,27 +271,27 @@ Given /^user (\d+) has the following notification rules:$/ do |contact_id, rules
     entity_tags        = rule['entity_tags'].split(',').map { |x| x.strip }
     warning_media      = rule['warning_media'].split(',').map { |x| x.strip }
     critical_media     = rule['critical_media'].split(',').map { |x| x.strip }
-    warning_blackhole  = rule['warning_blackhole'].downcase == 'true' ? 'true' : 'false'
-    critical_blackhole = rule['critical_blackhole'].downcase == 'true' ? 'true' : 'false'
+    warning_blackhole  = (rule['warning_blackhole'].downcase == 'true')
+    critical_blackhole = (rule['critical_blackhole'].downcase == 'true')
+    timezone = Flapjack::Data::Contact.find_by_id(contact_id, :redis => @redis).timezone
     time_restrictions  = []
     rule['time_restrictions'].split(',').map { |x| x.strip }.each do |time_restriction|
       case time_restriction
       when '8-18 weekdays'
-        # FIXME: get timezone from the user definition (or config[:default_contact_timezone])
-        time_zone = ActiveSupport::TimeZone.new("America/New_York")
-        weekdays_8_18 = IceCube::Schedule.new(time_zone.local(2013,2,1,8,0,0), :duration => 60 * 60 * 10)
+        weekdays_8_18 = IceCube::Schedule.new(timezone.local(2013,2,1,8,0,0), :duration => 60 * 60 * 10)
         weekdays_8_18.add_recurrence_rule(IceCube::Rule.weekly.day(:monday, :tuesday, :wednesday, :thursday, :friday))
-        time_restrictions << Flapjack::Data::NotificationRule.time_restriction_from_ice_cube_hash(weekdays_8_18.to_hash, time_zone)
+        time_restrictions << icecube_schedule_to_time_restriction(weekdays_8_18, timezone)
       end
     end
-    Flapjack::Data::NotificationRule.add({:contact_id         => contact_id,
-                                          :entities           => entities,
-                                          :entity_tags        => entity_tags,
-                                          :warning_media      => warning_media,
-                                          :critical_media     => critical_media,
-                                          :warning_blackhole  => warning_blackhole,
-                                          :critical_blackhole => critical_blackhole,
-                                          :time_restrictions  => time_restrictions}, :redis => @redis)
+    rule_data = {:contact_id         => contact_id,
+                 :entities           => entities,
+                 :entity_tags        => entity_tags,
+                 :warning_media      => warning_media,
+                 :critical_media     => critical_media,
+                 :warning_blackhole  => warning_blackhole,
+                 :critical_blackhole => critical_blackhole,
+                 :time_restrictions  => time_restrictions}
+    Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
   end
 end
 

data/lib/flapjack/coordinator.rb

@@ -128,11 +128,19 @@ module Flapjack
 
     # passed a hash with {PIKELET_TYPE => PIKELET_CFG, ...}
     def add_pikelets(pikelets_data = {})
+      start_piks = []
       pikelets_data.each_pair do |type, cfg|
         next unless pikelet = Flapjack::Pikelet.create(type,
           :config => cfg, :redis_config => @redis_options)
+        start_piks << pikelet
         @pikelets << pikelet
-        pikelet.start
+      end
+      begin
+        start_piks.each {|pik| pik.start }
+      rescue Exception => e
+        trace = e.backtrace.join("\n")
+        @logger.fatal "#{e.message}\n#{trace}"
+        stop
       end
     end
 

data/lib/flapjack/data/contact.rb

@@ -280,6 +280,7 @@ module Flapjack
       end
 
       # return the timezone of the contact, or the system default if none is set
+      # TODO cache?
       def timezone(opts = {})
         logger = opts[:logger]
 

data/lib/flapjack/data/notification_rule.rb

@@ -29,13 +29,11 @@ module Flapjack
         # sanity check
         return unless redis.exists("notification_rule:#{rule_id}")
 
-        rule = self.new({:id => rule_id}, {:redis => redis})
-        rule.refresh
-        rule
+        self.new({:id => rule_id.to_s}, {:redis => redis})
       end
 
       # replacing save! etc
-      def self.add(rule_data, options)
+      def self.add(rule_data, options = {})
         raise "Redis connection not set" unless redis = options[:redis]
 
         rule_id = SecureRandom.uuid
@@ -43,129 +41,235 @@ module Flapjack
         self.find_by_id(rule_id, :redis => redis)
       end
 
-      # add user's timezone string to the hash, deserialise
-      # time in the user's timezone also
-      def self.time_restriction_to_ice_cube_hash(tr, time_zone)
-        tr = symbolize(tr)
-
-        tr[:start_date] = tr[:start_time].dup
-        tr.delete(:start_time)
-
-        if tr[:start_date].is_a?(String)
-          tr[:start_date] = { :time => tr[:start_date] }
-        end
-        if tr[:start_date].is_a?(Hash)
-          tr[:start_date][:time] = time_zone.parse(tr[:start_date][:time])
-          tr[:start_date][:zone] = time_zone.name
-        end
-
-        if tr[:end_time].is_a?(String)
-          tr[:end_time] = { :time => tr[:end_time] }
-        end
-        if tr[:end_time].is_a?(Hash)
-          tr[:end_time][:time] = time_zone.parse(tr[:end_time][:time])
-          tr[:end_time][:zone] = time_zone.name
-        end
-
-        # rewrite Weekly to IceCube::WeeklyRule, etc
-        tr[:rrules].each {|rrule|
-          rrule[:rule_type] = "IceCube::#{rrule[:rule_type]}Rule"
-        }
-
-        tr
-      end
-
-      def self.time_restriction_from_ice_cube_hash(tr, time_zone)
-        tr[:start_date] = time_zone.utc_to_local(tr[:start_date][:time]).strftime "%Y-%m-%d %H:%M:%S"
-        tr[:end_time]   = time_zone.utc_to_local(tr[:end_time][:time]).strftime "%Y-%m-%d %H:%M:%S"
-
-        # rewrite IceCube::WeeklyRule to Weekly, etc
-        tr[:rrules].each {|rrule|
-          rrule[:rule_type] = /^.*\:\:(.*)Rule$/.match(rrule[:rule_type])[1]
-        }
-
-        tr[:start_time] = tr[:start_date].dup
-        tr.delete(:start_date)
-
-        tr
-      end
-
-      def refresh
-        rule_data = @redis.hgetall("notification_rule:#{@id}")
-
-        @contact_id         = rule_data['contact_id']
-        @entity_tags        = Yajl::Parser.parse(rule_data['entity_tags'] || '')
-        @entities           = Yajl::Parser.parse(rule_data['entities'] || '')
-        @time_restrictions  = Yajl::Parser.parse(rule_data['time_restrictions'] || '')
-        @warning_media      = Yajl::Parser.parse(rule_data['warning_media'] || '')
-        @critical_media     = Yajl::Parser.parse(rule_data['critical_media'] || '')
-        @warning_blackhole  = ((rule_data['warning_blackhole'] || 'false').downcase == 'true')
-        @critical_blackhole = ((rule_data['critical_blackhole'] || 'false').downcase == 'true')
-
+      def update(rule_data)
+        return false unless self.class.add_or_update(rule_data.merge(:id => @id),
+          :redis => @redis)
+        refresh
+        true
       end
 
-      def update(rule_data)
-        self.class.add_or_update(rule_data.merge(:id => @id), :redis => @redis)
-        self.refresh
+      # NB: ice_cube doesn't have much rule data validation, and has
+      # problems with infinite loops if the data can't logically match; see
+      #   https://github.com/seejohnrun/ice_cube/issues/127 &
+      #   https://github.com/seejohnrun/ice_cube/issues/137
+      # We may want to consider some sort of timeout-based check around
+      # anything that could fall into that.
+      #
+      # We don't want to replicate IceCube's from_hash behaviour here,
+      # but we do need to apply some sanity checking on the passed data.
+      def self.time_restriction_to_icecube_schedule(tr, timezone)
+        return unless !tr.nil? && tr.is_a?(Hash)
+        return if timezone.nil? && !timezone.is_a?(ActiveSupport::TimeZone)
+        return unless tr = prepare_time_restriction(tr, timezone)
+
+        IceCube::Schedule.from_hash(tr)
       end
 
       def to_json(*args)
-        hash = (Hash[ *([:id, :contact_id, :entity_tags, :entities,
-                 :time_restrictions, :warning_media, :critical_media,
-                 :warning_blackhole, :critical_blackhole].collect {|k|
-                   [k, self.send(k)]
-                 }).flatten(1) ])
-        hash.to_json
+        self.class.hashify(:id, :contact_id, :entity_tags, :entities,
+            :time_restrictions, :warning_media, :critical_media,
+            :warning_blackhole, :critical_blackhole) {|k|
+          [k, self.send(k)]
+        }.to_json
       end
 
       # tags or entity names match?
       # nil @entity_tags and nil @entities matches
       def match_entity?(event)
-        return true if (@entity_tags.nil? or @entity_tags.empty?) and
-                       (@entities.nil? or @entities.empty?)
-        return true if @entities.include?(event.split(':').first)
         # TODO: return true if event's entity tags match entity tag list on the rule
-        return false
+        ((@entity_tags.nil? || @entity_tags.empty?) && (@entities.nil? || @entities.empty?)) ||
+         (@entities.include?(event.split(':').first))
       end
 
       def blackhole?(severity)
-        return true if 'warning'.eql?(severity.downcase) and @warning_blackhole
-        return true if 'critical'.eql?(severity.downcase) and @critical_blackhole
-        return false
+        ('warning'.eql?(severity.downcase) && @warning_blackhole) ||
+          ('critical'.eql?(severity.downcase) && @critical_blackhole)
       end
 
       def media_for_severity(severity)
         case severity
         when 'warning'
-          media_list = @warning_media
+          @warning_media
         when 'critical'
-          media_list = @critical_media
+          @critical_media
         end
-        media_list
       end
 
     private
 
       def initialize(rule_data, opts = {})
         @redis  ||= opts[:redis]
-        @logger   = opts[:logger]
         raise "a redis connection must be supplied" unless @redis
-        @id = rule_data[:id]
+        @logger   = opts[:logger]
+        @id       = rule_data[:id]
+        refresh
       end
 
       def self.add_or_update(rule_data, options = {})
-        raise ":id is a required key in rule_data" unless rule_data[:id]
-
         redis = options[:redis]
+        raise "a redis connection must be supplied" unless redis
+
+        return unless self.validate_data(rule_data, options)
+
+        # whitelisting fields, rather than passing through submitted data directly
+        json_rule_data = {
+          :id                 => rule_data[:id].to_s,
+          :contact_id         => rule_data[:contact_id].to_s,
+          :entities           => Yajl::Encoder.encode(rule_data[:entities]),
+          :entity_tags        => Yajl::Encoder.encode(rule_data[:entity_tags]),
+          :time_restrictions  => Yajl::Encoder.encode(rule_data[:time_restrictions]),
+          :warning_media      => Yajl::Encoder.encode(rule_data[:warning_media]),
+          :critical_media     => Yajl::Encoder.encode(rule_data[:critical_media]),
+          :warning_blackhole  => rule_data[:warning_blackhole],
+          :critical_blackhole => rule_data[:critical_blackhole],
+        }
+
+        redis.sadd("contact_notification_rules:#{json_rule_data[:contact_id]}",
+                   json_rule_data[:id])
+        redis.hmset("notification_rule:#{json_rule_data[:id]}",
+                    *json_rule_data.flatten)
+        true
+      end
+
+      def self.prepare_time_restriction(time_restriction, timezone = nil)
+        # this will hand back a 'deep' copy
+        tr = symbolize(time_restriction)
+
+        return unless tr.has_key?(:start_time) && tr.has_key?(:end_time)
+
+        parsed_time = proc {|t|
+          if t.is_a?(Time)
+            t
+          else
+            begin; (timezone || Time).parse(t); rescue ArgumentError; nil; end
+          end
+        }
+
+        start_time = case tr[:start_time]
+        when String, Time
+          parsed_time.call(tr.delete(:start_time).dup)
+        when Hash
+          time_hash = tr.delete(:start_time).dup
+          parsed_time.call(time_hash[:time])
+        end
+
+        end_time = case tr[:end_time]
+        when String, Time
+          parsed_time.call(tr.delete(:end_time).dup)
+        when Hash
+          time_hash = tr.delete(:end_time).dup
+          parsed_time.call(time_hash[:time])
+        end
+
+        return unless start_time && end_time
+
+        tr[:start_date] = timezone ?
+                            {:time => start_time, :zone => timezone.name} :
+                            start_time
+
+        tr[:end_date]   = timezone ?
+                            {:time => end_time, :zone => timezone.name} :
+                            end_time
+
+        tr[:duration]   = end_time - start_time
+
+        # check that rrule types are valid IceCube rule types
+        return unless tr[:rrules].is_a?(Array) &&
+          tr[:rrules].all? {|rr| rr.is_a?(Hash)} &&
+          (tr[:rrules].map {|rr| rr[:rule_type]} -
+           ['Daily', 'Hourly', 'Minutely', 'Monthly', 'Secondly',
+            'Weekly', 'Yearly']).empty?
+
+        # rewrite Weekly to IceCube::WeeklyRule, etc
+        tr[:rrules].each {|rrule|
+          rrule[:rule_type] = "IceCube::#{rrule[:rule_type]}Rule"
+        }
 
-        rule_data[:entities]          = Yajl::Encoder.encode(rule_data[:entities])
-        rule_data[:entity_tags]       = Yajl::Encoder.encode(rule_data[:entity_tags])
-        rule_data[:time_restrictions] = Yajl::Encoder.encode(rule_data[:time_restrictions])
-        rule_data[:warning_media]     = Yajl::Encoder.encode(rule_data[:warning_media])
-        rule_data[:critical_media]    = Yajl::Encoder.encode(rule_data[:critical_media])
+        # TODO does this need to check classes for the following values?
+        # "validations": {
+        #   "day": [1,2,3,4,5]
+        # },
+        # "interval": 1,
+        # "week_start": 0
 
-        redis.sadd("contact_notification_rules:#{rule_data[:contact_id]}", rule_data[:id])
-        redis.hmset("notification_rule:#{rule_data[:id]}", *rule_data.flatten)
+        tr
+      end
+
+      def self.validate_data(d, options = {})
+        # hash with validation => error_message
+        validations = {proc { d.has_key?(:id) } =>
+                       "id not set",
+
+                       proc { d.has_key?(:entities) &&
+                              d[:entities].is_a?(Array) &&
+                              d[:entities].all? {|e| e.is_a?(String)} } =>
+                       "entities must be a list of strings",
+
+                       proc { d.has_key?(:entity_tags) &&
+                              d[:entity_tags].is_a?(Array) &&
+                              d[:entity_tags].all? {|et| et.is_a?(String)}} =>
+                       "entity_tags must be a list of strings",
+
+                       proc { (d.has_key?(:entities) &&
+                               d[:entities].is_a?(Array) &&
+                               (d[:entities].size > 0)) ||
+                              (d.has_key?(:entity_tags) &&
+                               d[:entity_tags].is_a?(Array) &&
+                               (d[:entity_tags].size > 0)) } =>
+                       "entities or entity tags must have at least one value",
+
+                       proc { d.has_key?(:time_restrictions) &&
+                              d[:time_restrictions].all? {|tr|
+                                !!prepare_time_restriction(symbolize(tr))
+                              }
+                            } =>
+                       "time restrictions are invalid",
+
+                       # TODO should the media types be checked against a whitelist?
+                       proc { d.has_key?(:warning_media) &&
+                              d[:warning_media].is_a?(Array) &&
+                              d[:warning_media].all? {|et| et.is_a?(String)}} =>
+                       "warning_media must be a list of strings",
+
+                       proc { d.has_key?(:critical_media) &&
+                              d[:critical_media].is_a?(Array) &&
+                              d[:critical_media].all? {|et| et.is_a?(String)}} =>
+                       "critical_media must be a list of strings",
+
+                       proc { d.has_key?(:warning_blackhole) &&
+                              [TrueClass, FalseClass].include?(d[:warning_blackhole].class) } =>
+                       "warning_blackhole must be true or false",
+
+                       proc { d.has_key?(:critical_blackhole) &&
+                              [TrueClass, FalseClass].include?(d[:critical_blackhole].class) } =>
+                       "critical_blackhole must be true or false",
+                      }
+
+        errors = validations.keys.inject([]) {|ret,vk|
+          ret << "Rule #{validations[vk]}" unless vk.call
+          ret
+        }
+
+        return true if errors.empty?
+
+        if logger = options[:logger]
+          error_str = errors.join(", ")
+          logger.info "validation error: #{error_str}"
+        end
+        false
+      end
+
+      def refresh
+        rule_data = @redis.hgetall("notification_rule:#{@id}")
+
+        @contact_id         = rule_data['contact_id']
+        @entity_tags        = Yajl::Parser.parse(rule_data['entity_tags'] || '')
+        @entities           = Yajl::Parser.parse(rule_data['entities'] || '')
+        @time_restrictions  = Yajl::Parser.parse(rule_data['time_restrictions'] || '')
+        @warning_media      = Yajl::Parser.parse(rule_data['warning_media'] || '')
+        @critical_media     = Yajl::Parser.parse(rule_data['critical_media'] || '')
+        @warning_blackhole  = ((rule_data['warning_blackhole'] || 'false').downcase == 'true')
+        @critical_blackhole = ((rule_data['critical_blackhole'] || 'false').downcase == 'true')
       end
 
     end