flapjack 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ede6c2a1d9cef33334510db3aafc14c3adfe81e
-  data.tar.gz: 1e9dd581aec598085752a982f13d93a0936799de
+  metadata.gz: a9f395ed95f7e409a6dccf833a149abce9ba2c3c
+  data.tar.gz: 02c26390a79ff90130c1c9c3a6fe1618c1c0341e
 SHA512:
-  metadata.gz: 4f7d21e0b77c86255e58a11786e7a288bc0b11101f1357d764f14bf8b0c6232566293fd577f3ba8652b81311c22e973954581ddcb08a243bfdd0b7d82ebd5cc1
-  data.tar.gz: 1cb8e1563662182441a1067baf645b9410133e480af1ec31fb28cb6d39978273e6b046ee67bfe01164a54a7988ff1d03bbd3eda7dc3359a3ef1da4f70c43a8ae
+  metadata.gz: caba9206c27111faae12acef641840b0fbd44cd7e8227462d0ba30bedf5a21cd71f54070ffc33015478eda857f06a28666a3772127a554f0b262545022bcd84f
+  data.tar.gz: c2af3088fc0154cc99f3520a254fa57e49ec110d1e0ccd0649fed0a21dc5462497eded455565131dc99e63e71d3725adf57ba725ae0442ea9b65197c78daac34

data/.travis.yml

@@ -2,6 +2,7 @@ language: ruby
 rvm:
   - "1.9.3"
   - "2.0.0"
+  - "2.1.0"
 env:
   - ENTITIES=10 INTERVAL=120
 gemfile:

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## Flapjack Changelog
 
+# 0.8.2 - 2014-01-16
+- Bug: no HTML parsing in summary of scheduled maintenance (thanks @marek-knappe) gh-413 (@ali-graham)
+- Bug: if tags and entities are present in a notification rule, both should match the event (thanks @jswoods) gh-417 (@jessereynolds)
+- Bug: improperly structured events crash the processor gh-411 (thanks @someword) (@ali-graham)
+- Bug: Critical events are no longer showing up as red in the flapjack UI gh-419 (thanks @jswoods) (@jessereynolds)
+
+# 0.8.1 - 2014-01-06
+- Bug: JSONAPI: 500 on GET /entities with no entities in the db gh-409 (@jessereynolds)
+
+# 0.8.0 - 2014-01-06
+- Feature: Start rewriting API as per jsonapi.org gh-253 (@ali-graham, @jessereynolds)
+- Feature: API consuming webapp beginnings gh-253 (@ali-graham, @auxesis, @jessereynolds)
+- Feature: New styles for navigation and so on (@auxesis)
+- Chore: Upgrade Rspec to v3 gh-389 (@ali-graham)
+- Chore: Make README clearer gh-406 (@auxesis)
+- Bug: Listing notification rules for a non existent contact gives 500, should be 404 gh-392 (@ali-graham)
+
 # 0.7.35 - 2013-12-10
 - Feature: allow flapper to flap with an arbitrary interval gh-383 (@jessereynolds)
 - Feature: Expose statistics for currency of all checks gh-386 (@jessereynolds)

data/bin/flapjack

@@ -163,7 +163,7 @@ when "start"
       return_value = flapjack_coord.call
     }
     puts " done."
-    exit(return_value + 128) unless (return_value.nil? || (return_value == 0))
+    exit(return_value) unless return_value.nil?
   end
 
 when "stop"

data/features/cli.feature

@@ -69,6 +69,7 @@ test:
 
   Scenario: Reloading flapjack configuration
     When I start flapjack with `flapjack start --config tmp/cucumber_cli/flapjack_cfg.yaml`
+    Then flapjack should start within 15 seconds
     When I run `mv tmp/cucumber_cli/flapjack_cfg.yaml tmp/cucumber_cli/flapjack_cfg.yaml.bak`
     Given a file named "flapjack_cfg.yaml" with:
 """
@@ -80,7 +81,7 @@ test:
 """
     When I send a SIGHUP to the flapjack process
     # TODO how to test for config file change?
-    When I send a SIGINT to the flapjack process
+    When I stop flapjack with `flapjack stop --config tmp/cucumber_cli/flapjack_cfg_d.yaml`
     Then flapjack should stop within 15 seconds
 
 

data/features/notification_rules.feature

@@ -3,12 +3,13 @@ Feature: Notification rules on a per contact basis
 
   Background:
     Given the following users exist:
-      | id  | first_name | last_name | email             | sms          | timezone         |
-      | c1  | Malak      | Al-Musawi | malak@example.com | +61400000001 | Asia/Baghdad     |
-      | c2  | Imani      | Farooq    | imani@example.com | +61400000002 | Europe/Moscow    |
-      | c3  | Vera       | Дурейко   | vera@example.com  | +61400000003 | Europe/Paris     |
-      | c4  | Lucia      | Moretti   | lucia@example.com | +61400000004 | Europe/Rome      |
-      | c5  | Wang Fang  | Wong      | fang@example.com  | +61400000005 | Asia/Shanghai    |
+      | id  | first_name | last_name | email             | sms          | timezone            |
+      | c1  | Malak      | Al-Musawi | malak@example.com | +61400000001 | Asia/Baghdad        |
+      | c2  | Imani      | Farooq    | imani@example.com | +61400000002 | Europe/Moscow       |
+      | c3  | Vera       | Дурейко   | vera@example.com  | +61400000003 | Europe/Paris        |
+      | c4  | Lucia      | Moretti   | lucia@example.com | +61400000004 | Europe/Rome         |
+      | c5  | Wang Fang  | Wong      | fang@example.com  | +61400000005 | Asia/Shanghai       |
+      | c6  | Jive       | Smith     | jive@example.com  | +61400000006 | America/Los_Angeles |
 
     And the following entities exist:
       | id  | name           | contacts |
@@ -16,7 +17,7 @@ Feature: Notification rules on a per contact basis
       | 2   | bar            | c1,c2,c3 |
       | 3   | baz            | c1,c3    |
       | 4   | buf            | c1,c2,c3 |
-      | 5   | foo-app-01.xyz | c4       |
+      | 5   | foo-app-01.xyz | c4,c6    |
 
     And user c1 has the following notification intervals:
       | email | sms |
@@ -66,6 +67,11 @@ Feature: Notification rules on a per contact basis
       | unknown_media | critical_media |
       | email         | email, sms     |
 
+    And user c6 has the following notification rules:
+      | entities       | tags            | warning_media | critical_media   |
+      |                |                 |               |                  |
+      | foo-app-01.xyz | check_disk      | email         | email            |
+
   @time_restrictions @time
   Scenario: Alerts only during specified time restrictions
     Given the timezone is Asia/Baghdad
@@ -380,6 +386,15 @@ Feature: Notification rules on a per contact basis
     And   a critical event is received
     Then  no sms alerts should be queued for +61400000004
 
+  @time
+  Scenario: Don't notify when tags in a rule don't match, but the entity does match
+    Given the check is check 'Memory Util' on entity 'foo-app-01.xyz'
+    And   the check is in an ok state
+    When  a critical event is received
+    And   1 minute passes
+    And   a critical event is received
+    Then  no email alerts should be queued for jive@example.com
+
   @time
   Scenario: Only notify during specified time periods in tag matched rules
     Given the timezone is Europe/Rome

data/features/steps/events_steps.rb

@@ -83,8 +83,7 @@ def submit_ok(entity, check)
     'state'   => 'ok',
     'summary' => '0% packet loss',
     'entity'  => entity,
-    'check'   => check,
-    'client'  => 'clientx'
+    'check'   => check
   }
   submit_event(event)
 end
@@ -95,8 +94,7 @@ def submit_warning(entity, check)
     'state'   => 'warning',
     'summary' => '25% packet loss',
     'entity'  => entity,
-    'check'   => check,
-    'client'  => 'clientx'
+    'check'   => check
   }
   submit_event(event)
 end
@@ -107,8 +105,7 @@ def submit_critical(entity, check)
     'state'   => 'critical',
     'summary' => '100% packet loss',
     'entity'  => entity,
-    'check'   => check,
-    'client'  => 'clientx'
+    'check'   => check
   }
   submit_event(event)
 end
@@ -119,8 +116,7 @@ def submit_unknown(entity, check)
     'state'   => 'unknown',
     'summary' => 'check execution error',
     'entity'  => entity,
-    'check'   => check,
-    'client'  => 'clientx'
+    'check'   => check
   }
   submit_event(event)
 end
@@ -131,8 +127,7 @@ def submit_acknowledgement(entity, check)
     'state'              => 'acknowledgement',
     'summary'            => "I'll have this fixed in a jiffy, saw the same thing yesterday",
     'entity'             => entity,
-    'check'              => check,
-    'client'             => 'clientx',
+    'check'              => check
   }
   submit_event(event)
 end
@@ -143,8 +138,7 @@ def submit_test(entity, check)
     'state'              => 'test_notifications',
     'summary'            => "test notification for all contacts interested in #{entity}",
     'entity'             => entity,
-    'check'              => check,
-    'client'             => 'clientx',
+    'check'              => check
   }
   submit_event(event)
 end

data/lib/flapjack/coordinator.rb

@@ -21,6 +21,8 @@ module Flapjack
       @redis_options = config.for_redis
       @pikelets = []
 
+      @received_signals = []
+
       @logger = Flapjack::Logger.new("flapjack-coordinator", @config.all['logger'])
     end
 
@@ -29,22 +31,39 @@ module Flapjack
 
       EM.synchrony do
         setup_signals if options[:signals]
-        add_pikelets(pikelets(@config.all))
+
+        begin
+          add_pikelets(pikelets(@config.all))
+          loop do
+            while sig = @received_signals.shift do
+              case sig
+              when 'INT', 'TERM', 'QUIT'
+                @exit_value = Signal.list[sig] + 128
+                raise Interrupt
+              when 'HUP'
+                reload
+              end
+            end
+            EM::Synchrony.sleep 0.25
+          end
+        rescue Exception => e
+          unless e.is_a?(Interrupt)
+            trace = e.backtrace.join("\n")
+            @logger.fatal "#{e.class.name}\n#{e.message}\n#{trace}"
+            @exit_value = 1
+          end
+          remove_pikelets(@pikelets)
+          EM.stop
+        end
       end
 
+      Syslog.close if Syslog.opened?
+
       @exit_value
     end
 
-    def stop(value = 0)
-      return unless @exit_value.nil?
-      @exit_value = value
-      remove_pikelets(@pikelets, :shutdown => true)
-      # Syslog.close if Syslog.opened? # TODO revisit in threading branch
-    end
+    private
 
-    # NB: global config options (e.g. daemonize, pidfile,
-    # logfile, redis options) won't be checked on reload.
-    # should we do a full restart if some of these change?
     def reload
       prev_pikelet_cfg = pikelets(@config.all)
 
@@ -85,85 +104,61 @@ module Flapjack
         added << pik.type
       end
 
-      # puts "removed"
-      # p removed
-
-      # puts "added"
-      # p added
-
       removed_pikelets = @pikelets.select {|pik| removed.include?(pik.type) }
 
-      # puts "removed pikelets"
-      # p removed_pikelets
-
       remove_pikelets(removed_pikelets)
 
       # is there a nicer way to only keep the parts of the hash with matching keys?
       added_pikelets = enabled_pikelet_cfg.select {|k, v| added.include?(k) }
 
-      # puts "added pikelet configs"
-      # p added_pikelets
-
       add_pikelets(added_pikelets)
     end
 
-  private
-
     # the global nature of this seems at odds with it calling stop
     # within a single coordinator instance. Coordinator is essentially
     # a singleton anyway...
     def setup_signals
-      Kernel.trap('INT')  { stop(Signal.list['INT']) }
-      Kernel.trap('TERM') { stop(Signal.list['TERM']) }
+      Kernel.trap('INT')    { @received_signals << 'INT' unless @received_signals.include?('INT') }
+      Kernel.trap('TERM')   { @received_signals << 'TERM' unless @received_signals.include?('TERM') }
       unless RbConfig::CONFIG['host_os'] =~ /mswin|windows|cygwin/i
-        Kernel.trap('QUIT') { stop(Signal.list['QUIT']) }
-        Kernel.trap('HUP')  { reload }
+        Kernel.trap('QUIT') { @received_signals << 'QUIT' unless @received_signals.include?('QUIT') }
+        Kernel.trap('HUP')  { @received_signals << 'HUP' unless @received_signals.include?('HUP') }
       end
     end
 
     # 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, :boot_time => @boot_time, :coordinator => self)
-        start_piks << pikelet
+          :config => cfg, :redis_config => @redis_options,
+          :boot_time => @boot_time)
+
         @pikelets << pikelet
-      end
-      begin
-        start_piks.each {|pik| pik.start }
-      rescue Exception => e
-        trace = e.backtrace.join("\n")
-        @logger.fatal "#{e.class.name}\n#{e.message}\n#{trace}"
-        stop
+        pikelet.start
       end
     end
 
     def remove_pikelets(piks, opts = {})
-      Fiber.new {
-        piks.map(&:stop)
-
-        loop do
-          # only prints state changes, otherwise pikelets not closing promptly can
-          # cause everything else to be spammy
-          piks.each do |pik|
-            old_status = pik.status
-            pik.update_status
-            status = pik.status
-            next if old_status.eql?(status)
-            # # can't log on exit w/Ruby 2.0
-            # @logger.info "#{pik.type}: #{old_status} -> #{status}"
-          end
+      piks.map(&:stop)
+
+      loop do
+        # only prints state changes, otherwise pikelets not closing promptly can
+        # cause everything else to be spammy
+        piks.each do |pik|
+          old_status = pik.status
+          pik.update_status
+          status = pik.status
+          next if old_status.eql?(status)
+          @logger.info "#{pik.type}: #{old_status} -> #{status}"
+        end
 
-          if piks.any? {|p| p.status == 'stopping' }
-            EM::Synchrony.sleep 0.25
-          else
-            EM.stop if opts[:shutdown]
-            @pikelets -= piks
-            break
-          end
+        if piks.any? {|p| p.status == 'stopping' }
+          EM::Synchrony.sleep 0.25
+        else
+          @pikelets -= piks
+          break
         end
-      }.resume
+      end
     end
 
     def pikelets(config_env)

data/lib/flapjack/data/event.rb

@@ -10,6 +10,44 @@ module Flapjack
 
       attr_reader :check, :summary, :details, :acknowledgement_id
 
+      REQUIRED_KEYS = ['type', 'state', 'entity', 'check', 'summary']
+      OPTIONAL_KEYS = ['time', 'details', 'acknowledgement_id', 'duration']
+
+      VALIDATIONS = {
+        proc {|e| ['service', 'action'].include?(e['type']) } =>
+          "type must be either 'service' or 'action'",
+
+        proc {|e| ['ok', 'warning', 'critical', 'unknown', 'acknowledgement', 'test_notifications'].include?(e['state']) } =>
+          "state must be one of 'ok', 'warning', 'critical', 'unknown', 'acknowledgement' or 'test_notifications'",
+
+        proc {|e| e['entity'].is_a?(String) } =>
+          "entity must be a string",
+
+        proc {|e| e['check'].is_a?(String) } =>
+          "check must be a string",
+
+        proc {|e| e['summary'].is_a?(String) } =>
+          "summary must be a string",
+
+        proc {|e| e['time'].nil? ||
+                  e['time'].is_a?(Integer) ||
+                 (e['time'].is_a?(String) && !!(parsed_duration =~ /^\d+$/)) } =>
+          "time must be a positive integer, or a string castable to one",
+
+        proc {|e| e['details'].nil? || e['details'].is_a?(String) } =>
+          "details must be a string",
+
+        proc {|e| e['acknowledgement_id'].nil? ||
+                  e['acknowledgement_id'].is_a?(String) ||
+                  e['acknowledgement_id'].is_a?(Integer) } =>
+          "acknowledgement_id must be a string or an integer",
+
+        proc {|e| e['duration'].nil? ||
+                  e['duration'].is_a?(Integer) ||
+                 (e['duration'].is_a?(String) && !!(parsed_duration =~ /^\d+$/)) } =>
+          "duration must be a positive integer, or a string castable to one",
+      }
+
       # Helper method for getting the next event.
       #
       # Has a blocking and non-blocking method signature.
@@ -19,7 +57,6 @@ module Flapjack
       #
       # Calling next with :block => false, will return a nil if there are no
       # events on the queue.
-      #
       def self.next(queue, opts = {})
         raise "Redis connection not set" unless redis = opts[:redis]
 
@@ -28,15 +65,17 @@ module Flapjack
                      :events_archive_maxage => (3 * 60 * 60) }
         options  = defaults.merge(opts)
 
+        archive_dest = nil
+        base_time_str = Time.now.utc.strftime("%Y%m%d%H")
+
         if options[:archive_events]
-          dest = "events_archive:#{Time.now.utc.strftime "%Y%m%d%H"}"
+          archive_dest = "events_archive:#{base_time_str}"
           if options[:block]
-            raw = redis.brpoplpush(queue, dest, 0)
+            raw = redis.brpoplpush(queue, archive_dest, 0)
           else
-            raw = redis.rpoplpush(queue, dest)
+            raw = redis.rpoplpush(queue, archive_dest)
             return unless raw
           end
-          redis.expire(dest, options[:events_archive_maxage])
         else
           if options[:block]
             raw = redis.brpop(queue, 0)[1]
@@ -45,15 +84,67 @@ module Flapjack
             return unless raw
           end
         end
-        begin
-          parsed = ::Oj.load( raw )
-        rescue Oj::Error => e
-          if options[:logger]
-            options[:logger].warn("Error deserialising event json: #{e}, raw json: #{raw.inspect}")
+        parsed = parse_and_validate(raw, :logger => options[:logger])
+        if parsed.nil?
+          # either bad json or invalid data -- in either case we'll
+          # store the raw data in a rejected list
+          rejected_dest = "events_rejected:#{base_time_str}"
+          if options[:archive_events]
+            redis.multi
+            redis.lrem(archive_dest, 1, raw)
+            redis.lpush(rejected_dest, raw)
+            redis.exec
+            redis.expire(archive_dest, options[:events_archive_maxage])
+          else
+            redis.lpush(rejected_dest, raw)
+          end
+          return
+        elsif options[:archive_events]
+          redis.expire(archive_dest, options[:events_archive_maxage])
+        end
+        self.new(parsed)
+      end
+
+      def self.parse_and_validate(raw, opts = {})
+        errors = []
+        if parsed = ::Oj.load(raw)
+
+          if parsed.is_a?(Hash)
+            missing_keys = REQUIRED_KEYS.select {|k|
+              !parsed.has_key?(k) || parsed[k].nil? || parsed[k].empty?
+            }
+            unless missing_keys.empty?
+              errors << "Event hash has missing keys '#{missing_keys.join('\', \'')}'"
+            end
+
+            unknown_keys =  parsed.keys - (REQUIRED_KEYS + OPTIONAL_KEYS)
+            unless unknown_keys.empty?
+              errors << "Event hash has unknown key(s) '#{unknown_keys.join('\', \'')}'"
+            end
+          else
+            errors << "Event must be a JSON hash, see https://github.com/flpjck/flapjack/wiki/DATA_STRUCTURES#event-queue"
           end
-          return nil
+
+          if errors.empty?
+            errors += VALIDATIONS.keys.inject([]) {|ret,vk|
+              ret << "Event #{VALIDATIONS[vk]}" unless vk.call(parsed)
+              ret
+            }
+          end
+
+          return parsed if errors.empty?
+        end
+
+        if opts[:logger]
+          error_str = errors.nil? ? '' : errors.join(', ')
+          opts[:logger].error("Invalid event data received #{error_str}#{parsed.inspect}")
+        end
+        nil
+      rescue Oj::Error => e
+        if opts[:logger]
+          opts[:logger].error("Error deserialising event json: #{e}, raw json: #{raw.inspect}")
         end
-        self.new( parsed )
+        nil
       end
 
       # creates, or modifies, an event object and adds it to the events list in redis

data/lib/flapjack/data/notification.rb

@@ -142,7 +142,13 @@ module Flapjack
             # for time, entity and tags
             matchers = rules.select do |rule|
               logger.debug("considering rule with entities: #{rule.entities} and tags: #{rule.tags.to_json}")
-              (rule.match_entity?(@event_id) || rule.match_tags?(@tags) || ! rule.is_specific?) &&
+              rule_has_tags     = rule.tags     ? (rule.tags.length > 0)     : false
+              rule_has_entities = rule.entities ? (rule.entities.length > 0) : false
+
+              matches_tags   = rule_has_tags     ? rule.match_tags?(@tags)       : true
+              matches_entity = rule_has_entities ? rule.match_entity?(@event_id) : true
+
+              ((matches_entity && matches_tags) || ! rule.is_specific?) &&
                 rule_occurring_now?(rule, :contact => contact, :default_timezone => default_timezone)
             end
 

data/lib/flapjack/data/notification_rule.rb

@@ -233,66 +233,68 @@ module Flapjack
         tr
       end
 
+      VALIDATION_PROCS = {
+        proc {|d| !d.has_key?(:entities) ||
+               ( d[:entities].nil? ||
+                 d[:entities].is_a?(Array) &&
+                 d[:entities].all? {|e| e.is_a?(String)} ) } =>
+        "entities must be a list of strings",
+
+        proc {|d| !d.has_key?(:tags) ||
+               ( d[:tags].nil? ||
+                 d[:tags].is_a?(Flapjack::Data::TagSet) &&
+                 d[:tags].all? {|et| et.is_a?(String)} ) } =>
+        "tags must be a tag_set of strings",
+
+        proc {|d| !d.has_key?(:time_restrictions) ||
+               ( d[:time_restrictions].nil? ||
+                 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| !d.has_key?(:unknown_media) ||
+               ( d[:unknown_media].nil? ||
+                 d[:unknown_media].is_a?(Array) &&
+                 d[:unknown_media].all? {|et| et.is_a?(String)} ) } =>
+        "unknown_media must be a list of strings",
+
+        proc {|d| !d.has_key?(:warning_media) ||
+               ( d[:warning_media].nil? ||
+                 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| !d.has_key?(:critical_media) ||
+               ( d[:critical_media].nil? ||
+                 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| !d.has_key?(:unknown_blackhole) ||
+               [TrueClass, FalseClass].include?(d[:unknown_blackhole].class) } =>
+        "unknown_blackhole must be true or false",
+
+        proc {|d| !d.has_key?(:warning_blackhole) ||
+               [TrueClass, FalseClass].include?(d[:warning_blackhole].class) } =>
+        "warning_blackhole must be true or false",
+
+        proc {|d| !d.has_key?(:critical_blackhole) ||
+               [TrueClass, FalseClass].include?(d[:critical_blackhole].class) } =>
+        "critical_blackhole must be true or false",
+      }
+
       def self.validate_data(d, options = {})
         id_not_required = !!options[:id_not_required]
         # hash with validation => error_message
         validations = {}
         validations.merge!({ proc { d.has_key?(:id) } => "id not set"}) unless id_not_required
-        validations.merge!({
-          proc { !d.has_key?(:entities) ||
-                 ( d[:entities].nil? ||
-                   d[:entities].is_a?(Array) &&
-                   d[:entities].all? {|e| e.is_a?(String)} ) } =>
-          "entities must be a list of strings",
-
-          proc { !d.has_key?(:tags) ||
-                 ( d[:tags].nil? ||
-                   d[:tags].is_a?(Flapjack::Data::TagSet) &&
-                   d[:tags].all? {|et| et.is_a?(String)} ) } =>
-          "tags must be a tag_set of strings",
-
-          proc { !d.has_key?(:time_restrictions) ||
-                 ( d[:time_restrictions].nil? ||
-                   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?(:unknown_media) ||
-                 ( d[:unknown_media].nil? ||
-                   d[:unknown_media].is_a?(Array) &&
-                   d[:unknown_media].all? {|et| et.is_a?(String)} ) } =>
-          "unknown_media must be a list of strings",
-
-          proc { !d.has_key?(:warning_media) ||
-                 ( d[:warning_media].nil? ||
-                   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].nil? ||
-                   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?(:unknown_blackhole) ||
-                 [TrueClass, FalseClass].include?(d[:unknown_blackhole].class) } =>
-          "unknown_blackhole must be true or false",
-
-          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",
-        })
+        validations.merge!(VALIDATION_PROCS)
 
         errors = validations.keys.inject([]) {|ret,vk|
-          ret << "Rule #{validations[vk]}" unless vk.call
+          ret << "Rule #{validations[vk]}" unless vk.call(d)
           ret
         }
 

data/lib/flapjack/gateways/web/views/checks.html.erb

@@ -23,7 +23,7 @@
       <%
         row_colour = case status
         when 'critical', 'unknown'
-          'error'
+          'danger'
         when 'ok', 'up'
           'success'
         else
@@ -33,23 +33,23 @@
         check_link = "/check?entity=" << u(entity) << "&amp;check=" << u(check)
 
       %>
-      <tr class="<%= row_colour %>">
+      <tr>
         <% unless row_entity && entity == row_entity %>
-          <td rowspan=<%= @states[entity].length %>>
+          <td rowspan="<%= @states[entity].length %>">
             <a href="<%= entity_link %>"><%= h entity %></a>
           </td>
           <% row_entity = entity %>
         <% end %>
-        <td><a href="<%= check_link %>" title="check detail"><%= h check %></a></td>
-        <td class="<%= status %>">
+        <td class="<%= row_colour %>"><a href="<%= check_link %>" title="check detail"><%= h check %></a></td>
+        <td class="<%= row_colour %>">
           <%= h status.upcase %>
           <% if in_unscheduled_outage%> (Ack'd)<% end %>
           <% if in_scheduled_outage %> (Sched)<% end %>
         </td>
-        <td><%= h summary %></td>
-        <td><%= h changed %></td>
-        <td><%= h updated %></td>
-        <td><%= h notified %></td>
+        <td class="<%= row_colour %>"><%= h summary %></td>
+        <td class="<%= row_colour %>"><%= h changed %></td>
+        <td class="<%= row_colour %>"><%= h updated %></td>
+        <td class="<%= row_colour %>"><%= h notified %></td>
       </tr>
 
     <% end %>

data/lib/flapjack/gateways/web/views/contact.html.erb

@@ -143,7 +143,7 @@
         <td><a href="/entity/<%= u(entity.name) %>" title="entity status"><%= h entity.name %></a></td>
         <td>
           <% checks.each do |check| %>
-          <%=   "<a href=\"/check?entity=#{u(entity.name)}&amp;check=#{u(check)}\" title=\"check status\">#{ h check }</a>" %>
+          <%= "<a href=\"/check?entity=#{u(entity.name)}&amp;check=#{u(check)}\" title=\"check status\">#{ h check }</a>" %>
           <% end %>
         </td>
       </tr>

data/lib/flapjack/gateways/web/views/entity.html.erb

@@ -38,10 +38,10 @@
           <% if in_unscheduled_outage%> (Ack'd)<% end %>
           <% if in_scheduled_outage %> (Sched)<% end %>
         </td>
-        <td><%= summary %></td>
-        <td><%= changed %></td>
-        <td><%= updated %></td>
-        <td><%= notified %></td>
+        <td><%= h summary %></td>
+        <td><%= h changed %></td>
+        <td><%= h updated %></td>
+        <td><%= h notified %></td>
       </tr>
     <% end %>
   </table>

data/lib/flapjack/gateways/web/views/layout.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
   <head>
-    <title><%= include_page_title %></title>
+    <title><%= h include_page_title %></title>
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <link rel="stylesheet" href="/css/bootstrap.min.css" media="screen">
     <link rel="stylesheet" href="/css/bootstrap-responsive.min.css" media="screen">

data/lib/flapjack/gateways/web/views/self_stats.html.erb

@@ -44,7 +44,7 @@
         <td>
           <ul>
             <% @current_checks_ages.each_pair do |age, check_count| %>
-              <li>&gt;= <%= age %>: <%= check_count %></li>
+              <li>&gt;= <%= h age %>: <%= h check_count %></li>
             <% end %>
           </ul>
         </td>

data/lib/flapjack/processor.rb

@@ -25,7 +25,6 @@ module Flapjack
       @config = opts[:config]
       @redis_config = opts[:redis_config] || {}
       @logger = opts[:logger]
-      @coordinator = opts[:coordinator]
 
       @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
 
@@ -102,11 +101,8 @@ module Flapjack
         if @exit_on_queue_empty && event.nil? && Flapjack::Data::Event.pending_count(@queue, :redis => @redis)
           # SHUT IT ALL DOWN!!!
           @logger.warn "Shutting down as exit_on_queue_empty is true, and the queue is empty"
-          @should_quit = true
-          @coordinator.stop
-          # FIXME: seems the above call doesn't block until the remove_pikelets fiber exits...
-          EM::Synchrony.sleep(1)
-          exit
+          Process.kill('INT', Process.pid)
+          break
         end
 
         process_event(event) unless event.nil?

data/lib/flapjack/version.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 end

data/spec/lib/flapjack/coordinator_spec.rb

@@ -29,19 +29,18 @@ describe Flapjack::Coordinator do
 
     fc = Flapjack::Coordinator.new(config)
     expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :config => cfg['processor'], :redis_config => {}, :boot_time => time, :coordinator => fc).
+        :config => cfg['processor'], :redis_config => {}, :boot_time => time).
       and_return(processor)
 
-    expect(fiber).to receive(:resume)
-    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
-
     expect(EM).to receive(:stop)
+    expect(EM::Synchrony).to receive(:sleep).and_return {
+      fc.instance_variable_set('@received_signals', ['INT'])
+    }
 
-    # Syslog.should_receive(:opened?).and_return(true)
-    # Syslog.should_receive(:close)
+    expect(Syslog).to receive(:opened?).and_return(true)
+    expect(Syslog).to receive(:close)
 
     fc.start(:signals => false)
-    fc.stop
   end
 
   it "handles an exception raised by a pikelet and shuts down" do
@@ -63,19 +62,15 @@ describe Flapjack::Coordinator do
 
     fc = Flapjack::Coordinator.new(config)
     expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :config => cfg['processor'], :redis_config => {}, :boot_time => time, :coordinator => fc)
+        :config => cfg['processor'], :redis_config => {}, :boot_time => time)
       .and_return(processor)
 
-    expect(fiber).to receive(:resume)
-    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
-
     expect(EM).to receive(:stop)
 
-    # Syslog.should_receive(:opened?).and_return(true)
-    # Syslog.should_receive(:close)
+    expect(Syslog).to receive(:opened?).and_return(true)
+    expect(Syslog).to receive(:close)
 
     fc.start(:signals => false)
-    fc.stop
   end
 
   it "loads an old executive pikelet config block with no new data" do
@@ -100,22 +95,21 @@ describe Flapjack::Coordinator do
 
     fc = Flapjack::Coordinator.new(config)
     expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :config => cfg['executive'], :redis_config => {}, :boot_time => time, :coordinator => fc).
+        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
       and_return(processor)
     expect(Flapjack::Pikelet).to receive(:create).with('notifier',
-        :config => cfg['executive'], :redis_config => {}, :boot_time => time, :coordinator => fc).
+        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
       and_return(notifier)
 
-    expect(fiber).to receive(:resume)
-    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
-
     expect(EM).to receive(:stop)
+    expect(EM::Synchrony).to receive(:sleep).and_return {
+      fc.instance_variable_set('@received_signals', ['INT'])
+    }
 
-    # Syslog.should_receive(:opened?).and_return(true)
-    # Syslog.should_receive(:close)
+    expect(Syslog).to receive(:opened?).and_return(true)
+    expect(Syslog).to receive(:close)
 
     fc.start(:signals => false)
-    fc.stop
   end
 
   it "loads an old executive pikelet config block with some new data" do
@@ -138,19 +132,18 @@ describe Flapjack::Coordinator do
     fc = Flapjack::Coordinator.new(config)
     expect(Flapjack::Pikelet).to receive(:create).with('processor',
         :config => cfg['executive'].merge(cfg['processor']),
-        :redis_config => {}, :boot_time => time, :coordinator => fc).
+        :redis_config => {}, :boot_time => time).
       and_return(processor)
 
-    expect(fiber).to receive(:resume)
-    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
-
     expect(EM).to receive(:stop)
+    expect(EM::Synchrony).to receive(:sleep).and_return {
+      fc.instance_variable_set('@received_signals', ['INT'])
+    }
 
-    # Syslog.should_receive(:opened?).and_return(true)
-    # Syslog.should_receive(:close)
+    expect(Syslog).to receive(:opened?).and_return(true)
+    expect(Syslog).to receive(:close)
 
     fc.start(:signals => false)
-    fc.stop
   end
 
   it "traps system signals and shuts down" do
@@ -166,10 +159,9 @@ describe Flapjack::Coordinator do
     expect(config).to receive(:all).and_return({})
     expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
-    expect(fc).to receive(:stop).exactly(3).times
-    expect(fc).to receive(:reload)
 
     fc.send(:setup_signals)
+    expect(fc.instance_variable_get('@received_signals')).to eq(['INT', 'TERM', 'QUIT', 'HUP'])
   end
 
   it "only traps two system signals on Windows" do
@@ -185,9 +177,9 @@ describe Flapjack::Coordinator do
     expect(config).to receive(:all).and_return({})
     expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
-    expect(fc).to receive(:stop).twice
 
     fc.send(:setup_signals)
+    expect(fc.instance_variable_get('@received_signals')).to eq(['INT', 'TERM'])
   end
 
   it "stops one pikelet and starts another on reload" do
@@ -218,19 +210,14 @@ describe Flapjack::Coordinator do
     jabber = double('jabber')
     expect(Flapjack::Pikelet).to receive(:create).
       with('jabber', :config => {"enabled" => true}, :redis_config => {},
-        :boot_time => time, :coordinator => fc).
+        :boot_time => time).
       and_return(jabber)
     expect(jabber).to receive(:start)
 
-    expect(fiber).to receive(:resume)
-    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
-
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
-    fc.reload
+    fc.send(:reload)
     expect(fc.instance_variable_get('@pikelets')).to eq([jabber])
-
-
   end
 
   it "reloads a pikelet config without restarting it" do
@@ -259,7 +246,7 @@ describe Flapjack::Coordinator do
     fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
-    fc.reload
+    fc.send(:reload)
     expect(fc.instance_variable_get('@pikelets')).to eq([processor])
   end
 
@@ -286,9 +273,6 @@ describe Flapjack::Coordinator do
     expect(processor).to receive(:update_status)
     expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    expect(fiber).to receive(:resume)
-    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
-
     new_exec = double('new_executive')
     expect(new_exec).to receive(:start)
 
@@ -297,12 +281,12 @@ describe Flapjack::Coordinator do
 
     expect(Flapjack::Pikelet).to receive(:create).
       with('processor', :config => new_cfg['processor'], :redis_config => {},
-        :boot_time => time, :coordinator => fc).
+        :boot_time => time).
       and_return(new_exec)
 
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
-    fc.reload
+    fc.send(:reload)
     expect(fc.instance_variable_get('@pikelets')).to eq([new_exec])
   end
 

data/spec/lib/flapjack/data/event_spec.rb

@@ -23,36 +23,163 @@ describe Flapjack::Data::Event do
   context 'class' do
 
     it "returns the next event (blocking, archiving)" do
-      expect(mock_redis).to receive(:brpoplpush).with('events', /^events_archive:/, 0).and_return(event_data.to_json)
+      expect(mock_redis).to receive(:brpoplpush).
+        with('events', /^events_archive:/, 0).and_return(event_data.to_json)
       expect(mock_redis).to receive(:expire)
 
-      result = Flapjack::Data::Event.next('events', :block => true, :archive_events => true, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => true,
+        :archive_events => true, :redis => mock_redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (blocking, not archiving)" do
-      expect(mock_redis).to receive(:brpop).with('events', 0).and_return(['events', event_data.to_json])
+      expect(mock_redis).to receive(:brpop).with('events', 0).
+        and_return(['events', event_data.to_json])
 
-      result = Flapjack::Data::Event.next('events', :block => true, :archive_events => false, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events',:block => true,
+        :archive_events => false, :redis => mock_redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, archiving)" do
-      expect(mock_redis).to receive(:rpoplpush).with('events', /^events_archive:/).and_return(event_data.to_json)
+      expect(mock_redis).to receive(:rpoplpush).
+        with('events', /^events_archive:/).and_return(event_data.to_json)
       expect(mock_redis).to receive(:expire)
 
-      result = Flapjack::Data::Event.next('events', :block => false, :archive_events => true, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => false,
+        :archive_events => true, :redis => mock_redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, not archiving)" do
-      expect(mock_redis).to receive(:rpop).with('events').and_return(event_data.to_json)
+      expect(mock_redis).to receive(:rpop).with('events').
+        and_return(event_data.to_json)
 
-      result = Flapjack::Data::Event.next('events', :block => false, :archive_events => false, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => false,
+        :archive_events => false, :redis => mock_redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
-    it "handles invalid event JSON"
+    it "rejects invalid event JSON (archiving)" do
+      bad_event_json = '{{{'
+      expect(mock_redis).to receive(:brpoplpush).
+        with('events', /^events_archive:/, 0).and_return(bad_event_json)
+      expect(mock_redis).to receive(:multi)
+      expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+      expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+      expect(mock_redis).to receive(:exec)
+      expect(mock_redis).to receive(:expire)
+
+      result = Flapjack::Data::Event.next('events', :block => true,
+        :archive_events => true, :redis => mock_redis)
+      expect(result).to be_nil
+    end
+
+    it "rejects invalid event JSON (not archiving)" do
+      bad_event_json = '{{{'
+      expect(mock_redis).to receive(:brpop).with('events', 0).
+        and_return(['events', bad_event_json])
+      expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+
+      result = Flapjack::Data::Event.next('events', :block => true,
+        :archive_events => false, :redis => mock_redis)
+      expect(result).to be_nil
+    end
+
+    ['type', 'state', 'entity', 'check', 'summary'].each do |required_key|
+
+      it "rejects an event with missing '#{required_key}' key (archiving)" do
+        bad_event_data = event_data.clone
+        bad_event_data.delete(required_key)
+        bad_event_json = bad_event_data.to_json
+        expect(mock_redis).to receive(:brpoplpush).
+          with('events', /^events_archive:/, 0).and_return(bad_event_json)
+        expect(mock_redis).to receive(:multi)
+        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(mock_redis).to receive(:exec)
+        expect(mock_redis).to receive(:expire)
+
+        result = Flapjack::Data::Event.next('events', :block => true,
+          :archive_events => true, :redis => mock_redis)
+        expect(result).to be_nil
+      end
+
+      it "rejects an event with missing '#{required_key}' key (not archiving)" do
+        bad_event_data = event_data.clone
+        bad_event_data.delete(required_key)
+        bad_event_json = bad_event_data.to_json
+        expect(mock_redis).to receive(:brpop).with('events', 0).
+          and_return(['events', bad_event_json])
+        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+
+        result = Flapjack::Data::Event.next('events', :block => true,
+          :archive_events => false, :redis => mock_redis)
+        expect(result).to be_nil
+      end
+
+      it "rejects an event with invalid '#{required_key}' key (archiving)" do
+        bad_event_data = event_data.clone
+        bad_event_data[required_key] = {'hello' => 'there'}
+        bad_event_json = bad_event_data.to_json
+        expect(mock_redis).to receive(:brpoplpush).
+          with('events', /^events_archive:/, 0).and_return(bad_event_json)
+        expect(mock_redis).to receive(:multi)
+        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(mock_redis).to receive(:exec)
+        expect(mock_redis).to receive(:expire)
+
+        result = Flapjack::Data::Event.next('events', :block => true,
+          :archive_events => true, :redis => mock_redis)
+        expect(result).to be_nil
+      end
+
+      it "rejects an event with invalid '#{required_key}' key (not archiving)" do
+        bad_event_data = event_data.clone
+        bad_event_data[required_key] = {'hello' => 'there'}
+        bad_event_json = bad_event_data.to_json
+        expect(mock_redis).to receive(:brpop).with('events', 0).
+          and_return(['events', bad_event_json])
+        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+
+        result = Flapjack::Data::Event.next('events', :block => true,
+          :archive_events => false, :redis => mock_redis)
+        expect(result).to be_nil
+      end
+    end
+
+    ['time', 'details', 'acknowledgement_id', 'duration'].each do |optional_key|
+      it "rejects an event with invalid '#{optional_key}' key (archiving)" do
+        bad_event_data = event_data.clone
+        bad_event_data[optional_key] = {'hello' => 'there'}
+        bad_event_json = bad_event_data.to_json
+        expect(mock_redis).to receive(:brpoplpush).
+          with('events', /^events_archive:/, 0).and_return(bad_event_json)
+        expect(mock_redis).to receive(:multi)
+        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(mock_redis).to receive(:exec)
+        expect(mock_redis).to receive(:expire)
+
+        result = Flapjack::Data::Event.next('events', :block => true,
+          :archive_events => true, :redis => mock_redis)
+        expect(result).to be_nil
+      end
+
+      it "rejects an event with invalid '#{optional_key}' key (archiving)" do
+        bad_event_data = event_data.clone
+        bad_event_data[optional_key] = {'hello' => 'there'}
+        bad_event_json = bad_event_data.to_json
+        expect(mock_redis).to receive(:brpop).with('events', 0).
+          and_return(['events', bad_event_json])
+        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+
+        result = Flapjack::Data::Event.next('events', :block => true,
+          :archive_events => false, :redis => mock_redis)
+        expect(result).to be_nil
+      end
+    end
 
     it "returns a count of pending events" do
       events_len = 23

data/tasks/benchmarks.rake

@@ -54,10 +54,12 @@ namespace :benchmarks do
     end
     time_flapjack_start = Time.now.to_f
     puts "Starting flapjack..."
-    if system({"FLAPJACK_ENV" => FLAPJACK_ENV,
+    result = system({"FLAPJACK_ENV" => FLAPJACK_ENV,
                "CPUPROFILE"   => "artifacts/flapjack-perftools-cpuprofile",
                "RUBYOPT"      => "-r#{perftools}"},
               "bin/flapjack start --no-daemonize --config tasks/support/flapjack_config_benchmark.yaml")
+    status = $?
+    if status.exited? && (Signal.list['INT'] + 128).eql?($?.exitstatus)
       puts "Flapjack run completed successfully"
     else
       raise "Problem starting flapjack: #{$?}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flapjack
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Lindsay Holmwood
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-07 00:00:00.000000000 Z
+date: 2014-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dante