flapjack 0.6.53 → 0.6.54

data/etc/flapjack_config.yaml.example

@@ -35,10 +35,14 @@ development:
     sms_queue: sms_notifications
     jabber_queue: jabber_notifications
     notification_log_file: log/flapjack-notification.log
+    logger:
+      level: INFO
   gateways:
     email:
       enabled: yes
       queue: email_notifications
+      logger:
+        level: INFO
       smtp_config:
         port: 2525
         # address: "localhost"
@@ -53,6 +57,8 @@ development:
       queue: sms_notifications
       username: "ermahgerd"
       password: "xxxx"
+      logger:
+        level: INFO
     jabber:
       enabled: yes
       queue: jabber_notifications
@@ -64,6 +70,8 @@ development:
       rooms:
         - "gimp@conference.jabber.domain.tld"
         - "log@conference.jabber.domain.tld"
+      logger:
+        level: INFO
     oobetet:
       enabled: yes
       server: "jabber.domain.tld"
@@ -79,17 +87,25 @@ development:
         - "flapjacktest@conference.jabber.domain.tld"
         - "gimp@conference.jabber.domain.tld"
         - "log@conference.jabber.domain.tld"
+      logger:
+        level: INFO
     pagerduty:
       enabled: yes
       queue: pagerduty_notifications
+      logger:
+        level: INFO
     web:
       enabled: yes
       port: 5080
       access_log: "log/web_access.log"
+      logger:
+        level: INFO
     api:
       enabled: yes
       port: 5081
       access_log: "log/api_access.log"
+      logger:
+        level: INFO
 
 test:
   redis:

data/features/events.feature

@@ -160,3 +160,66 @@ Feature: events
     And   an ok event is received for check 'abc' on entity 'def'
     Then  a notification should not be generated for check 'abc' on entity 'def'
 
+  Scenario: Flapper (down for one minute, up for one minute, repeat)
+    Given check 'abc' for entity 'def' is in an ok state
+    When  a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    # 30 seconds
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    # 60 seconds
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    # 120 seconds
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    # 150 seconds
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    And   a failure event is received for check 'abc' on entity 'def'
+    Then  a notification should not be generated for check 'abc' on entity 'def'
+    When  10 seconds passes
+    # 180 seconds
+    And   an ok event is received for check 'abc' on entity 'def'
+    Then  a notification should be generated for check 'abc' on entity 'def'

data/features/steps/events_steps.rb

@@ -147,17 +147,17 @@ end
 
 # TODO logging is a side-effect, should test for notification generation itself
 Then /^a notification should not be generated for check '([\w\.\-]+)' on entity '([\w\.\-]+)'$/ do |check, entity|
-  message = @app.logger.messages.find_all {|m| m =~ /ending notifications for event #{entity}:#{check}/ }.last
-  message ? happy = message.match(/Not sending notifications/) : happy = false
+  message = @logger.messages.find_all {|m| m =~ /enerating notifications for event #{entity}:#{check}/ }.last
+  message ? happy = message.match(/Not generating notifications/) : happy = false
   happy.should be_true
 end
 
 Then /^a notification should be generated for check '([\w\.\-]+)' on entity '([\w\.\-]+)'$/ do |check, entity|
-  message = @app.logger.messages.find_all {|m| m =~ /ending notifications for event #{entity}:#{check}/ }.last
-  message ? happy = message.match(/Sending notifications/) : happy = false
+  message = @logger.messages.find_all {|m| m =~ /enerating notifications for event #{entity}:#{check}/ }.last
+  message ? happy = message.match(/Generating notifications/) : happy = false
   happy.should be_true
 end
 
 Then /^show me the notifications?$/ do
-  puts @app.logger.messages.join("\n")
+  puts @logger.messages.join("\n")
 end

data/features/steps/notifications_steps.rb

@@ -127,7 +127,8 @@ When /^the SMS notification handler runs successfully$/ do
 
   Flapjack::Gateways::SmsMessagenet.instance_variable_set('@config', {'username' => 'abcd', 'password' => 'efgh'})
   Flapjack::Gateways::SmsMessagenet.instance_variable_set('@logger', @logger)
-  Flapjack::Gateways::SmsMessagenet.instance_variable_set('@sent', 0)
+  Flapjack::Gateways::SmsMessagenet.start
+
   Flapjack::Gateways::SmsMessagenet.perform(@sms_notification)
 end
 
@@ -135,15 +136,16 @@ When /^the SMS notification handler fails to send an SMS$/ do
   @request = stub_request(:get, /^#{Regexp.escape(Flapjack::Gateways::SmsMessagenet::MESSAGENET_URL)}/).to_return(:status => [500, "Internal Server Error"])
   Flapjack::Gateways::SmsMessagenet.instance_variable_set('@config', {'username' => 'abcd', 'password' => 'efgh'})
   Flapjack::Gateways::SmsMessagenet.instance_variable_set('@logger', @logger)
-  Flapjack::Gateways::SmsMessagenet.instance_variable_set('@sent', 0)
+  Flapjack::Gateways::SmsMessagenet.start
+
   Flapjack::Gateways::SmsMessagenet.perform(@sms_notification)
 end
 
 When /^the email notification handler runs successfully$/ do
   Resque.redis = @redis
-  Flapjack::Gateways::Email.bootstrap(:config => {'smtp_config' => {'host' => '127.0.0.1', 'port' => 2525}})
+  Flapjack::Gateways::Email.instance_variable_set('@config', {'smtp_config' => {'host' => '127.0.0.1', 'port' => 2525}})
   Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-  Flapjack::Gateways::Email.instance_variable_set('@sent', 0)
+  Flapjack::Gateways::Email.start
 
   # poor man's stubbing
   EM::P::SmtpClient.class_eval {
@@ -159,9 +161,9 @@ end
 
 When /^the email notification handler fails to send an email$/ do
   Resque.redis = @redis
-  Flapjack::Gateways::Email.bootstrap(:config => {'smtp_config' => {'host' => '127.0.0.1', 'port' => 2525}})
+  Flapjack::Gateways::Email.instance_variable_set('@config', {'smtp_config' => {'host' => '127.0.0.1', 'port' => 2525}})
   Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-  Flapjack::Gateways::Email.instance_variable_set('@sent', 0)
+  Flapjack::Gateways::Email.start
 
   # poor man's stubbing
   EM::P::SmtpClient.class_eval {

data/features/steps/time_travel_steps.rb

@@ -6,24 +6,24 @@ require 'chronic'
 When /^(.+) passes$/ do |time|
   period = Chronic.parse("#{time} from now")
   Delorean.time_travel_to(period)
-  puts "Time Travelled to #{Time.now.to_s}"
+  # puts "Time Travelled to #{Time.now.to_s}"
 end
 
 Given /^I time travel to (.+)$/ do |period|
   Delorean.time_travel_to(period)
-  puts "Time Travelled to #{Time.now.to_s}"
+  # puts "Time Travelled to #{Time.now.to_s}"
 end
 
 Given /^I come back to the present$/ do
   Delorean.back_to_the_present
-  puts "Time Travelled to the present, #{Time.now.to_s}"
+  # puts "Time Travelled to the present, #{Time.now.to_s}"
 end
 
 Given /^I time travel in (.+) to (.+)$/ do |zone_name, timestamp|
   zone = ::Time.find_zone!(zone_name)
   time = zone.parse timestamp
   Delorean.time_travel_to time
-  puts "Time Travelled to #{Time.now.to_s}"
+  # puts "Time Travelled to #{Time.now.to_s}"
 end
 
 Then /^the time in UTC should be about (.+)$/ do |timestamp|

data/features/support/env.rb

@@ -61,8 +61,7 @@ end
 Before do
   @logger = MockLogger.new
   # Use a separate database whilst testing
-  @app = Flapjack::Executive.new
-  @app.bootstrap(:logger => @logger,
+  @app = Flapjack::Executive.new(:logger => @logger,
     :config => {'email_queue' => 'email_notifications',
                 'sms_queue' => 'sms_notifications'},
     :redis_config => redis_opts)

data/flapjack.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Flapjack::VERSION
 
-  gem.add_dependency 'daemons'
+  gem.add_dependency 'dante'
   gem.add_dependency 'log4r'
   gem.add_dependency 'yajl-ruby'
   gem.add_dependency 'eventmachine', '~> 1.0.0'

data/lib/flapjack/configuration.rb

@@ -7,19 +7,12 @@ module Flapjack
 
   class Configuration
 
+    attr_reader :filename
+
     def initialize(opts = {})
       @logger = opts[:logger]
-      unless @logger
-        @logger       = Logger.new(STDOUT)
-        @logger.level = Logger::ERROR
-      end
-    end
-
-    def logger
-      @logger
     end
 
-    # TODO reduce/remove the use of this, just access parts
     def all
       @config_env
     end
@@ -53,29 +46,34 @@ module Flapjack
     end
 
     def load(filename)
+      @filename = nil
+      @config_env = nil
+
       unless File.file?(filename)
-        logger.error "Could not find file '#{filename}'"
+        @logger.error "Could not find file '#{filename}'" if @logger
         return
       end
 
       unless defined?(FLAPJACK_ENV)
-        logger.error "Environment variable 'FLAPJACK_ENV' is not set"
+        @logger.error "Environment variable 'FLAPJACK_ENV' is not set" if @logger
         return
       end
 
       config = YAML::load_file(filename)
 
       if config.nil?
-        logger.error "Could not load config file '#{filename}'"
+        @logger.error "Could not load config file '#{filename}'" if @logger
         return
       end
 
       @config_env = config[FLAPJACK_ENV]
 
       if @config_env.nil?
-        logger.error "No config data for environment '#{FLAPJACK_ENV}' found in '#{filename}'"
+        @logger.error "No config data for environment '#{FLAPJACK_ENV}' found in '#{filename}'" if @logger
         return
       end
+
+      @filename = filename
     end
 
   end

data/lib/flapjack/coordinator.rb

@@ -1,297 +1,177 @@
 #!/usr/bin/env ruby
 
 require 'eventmachine'
-# the redis/synchrony gems need to be required in this particular order, see
-# the redis-rb README for details
-require 'hiredis'
 require 'em-synchrony'
-require 'redis/connection/synchrony'
-require 'redis'
-require 'em-resque'
-require 'em-resque/worker'
-require 'thin'
 
 require 'flapjack/configuration'
 require 'flapjack/patches'
-require 'flapjack/daemonizing'
 require 'flapjack/executive'
 require 'flapjack/redis_pool'
 
 require 'flapjack/pikelet'
-require 'flapjack/gateways/base'
-
 require 'flapjack/executive'
 
-require 'flapjack/gateways/api'
-require 'flapjack/gateways/jabber'
-require 'flapjack/gateways/oobetet'
-require 'flapjack/gateways/pagerduty'
-require 'flapjack/gateways/email'
-require 'flapjack/gateways/sms_messagenet'
-require 'flapjack/gateways/web'
-
 module Flapjack
 
   class Coordinator
 
-    include Flapjack::Daemonizable
-
     def initialize(config)
       @config = config
       @redis_options = config.for_redis
       @pikelets = []
 
-      @logger = Log4r::Logger.new("flapjack-coordinator")
-      @logger.add(Log4r::StdoutOutputter.new("flapjack-coordinator"))
-      @logger.add(Log4r::SyslogOutputter.new("flapjack-coordinator"))
-    end
+      # TODO convert this to use flapjack-logger
+      logger_name = "flapjack-coordinator"
+      @logger = Log4r::Logger.new(logger_name)
 
-    def start(options = {})
-      @signals = options[:signals]
-      if options[:daemonize]
-        @signals = options[:signals]
-        daemonize
-      else
-        run(:signals => options[:signals])
+      formatter = Log4r::PatternFormatter.new(:pattern => "%d [%l] :: #{logger_name} :: %m",
+        :date_pattern => "%Y-%m-%dT%H:%M:%S%z")
+
+      [Log4r::StdoutOutputter, Log4r::SyslogOutputter].each do |outp_klass|
+        outp = outp_klass.new(logger_name)
+        outp.formatter = formatter
+        @logger.add(outp)
       end
     end
 
-    def after_daemonize
-      run(:signals => @signals)
+    def start(options = {})
+      EM.synchrony do
+        add_pikelets(pikelets(@config.all))
+        setup_signals if options[:signals]
+      end
     end
 
     def stop
       return if @stopping
       @stopping = true
-      shutdown
+      remove_pikelets(@pikelets, :shutdown => true)
     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)
 
-    def run(options = {})
+      removed = []
+      added = []
+      ask_running = []
 
-      EM.synchrony do
+      cfg_filename = @config.filename
+      @config = Flapjack::Configuration.new
+      @config.load(cfg_filename)
 
-        config_env = @config.all
+      enabled_pikelet_cfg = pikelets(@config.all)
 
-        pikelets(config_env).each_pair do |pikelet_class, pikelet_cfg|
-          next unless pikelet_cfg['enabled']
-          build_pikelet(pikelet_class, pikelet_cfg)
-        end
+      (prev_pikelet_cfg.keys + enabled_pikelet_cfg.keys).each do |type|
 
-        gateways(config_env).each_pair do |gateway_class, gateway_cfg|
-          # TODO split out gateway logic to build_gateway
-          next unless gateway_cfg['enabled']
-          build_pikelet(gateway_class, gateway_cfg)
+        if prev_pikelet_cfg.keys.include?(type)
+          if enabled_pikelet_cfg.keys.include?(type)
+            ask_running << type
+          else
+            removed << type
+          end
+        elsif enabled_pikelet_cfg.keys.include?(type)
+          added << type
         end
 
-        setup_signals if @signals
       end
 
-    end
-
-    # 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 }
-      Kernel.trap('TERM') { stop }
-      unless RbConfig::CONFIG['host_os'] =~ /mswin|windows|cygwin/i
-        Kernel.trap('QUIT') { stop }
-        # Kernel.trap('HUP')  { }
+      @pikelets.select {|pik| ask_running.include?(pik.type) }.each do |pik|
+        # for sections previously there and still there, ask them
+        # to make the config change; they will if they can, or will signal
+        # restart is needed if not
+
+        # reload() returns trinary value here; true means the change was made, false
+        # means the pikelet needs to be restarted, nil means no change
+        # was required
+        next unless pik.reload(enabled_pikelet_cfg[pik.type]).is_a?(FalseClass)
+        removed << pik.type
+        added << pik.type
       end
-    end
 
-    def build_pikelet(pikelet_class, pikelet_cfg)
-      @logger.debug "coordinator is now initialising the #{pikelet_class} pikelet"
+      # puts "removed"
+      # p removed
 
-      inc_mod = pikelet_class.included_modules
-      ext_mod = extended_modules(pikelet_class)
+      # puts "added"
+      # p added
 
-      pikelet = nil
-      fiber = nil
+      removed_pikelets = @pikelets.select {|pik| removed.include?(pik.type) }
 
-      if inc_mod.include?(Flapjack::GenericPikelet)
-        pikelet = pikelet_class.new
-        pikelet.bootstrap(:config => pikelet_cfg, :redis_config => @redis_options)
-      else
-        pikelet_class.bootstrap(:config => pikelet_cfg, :redis_config => @redis_options)
+      # puts "removed pikelets"
+      # p removed_pikelets
 
-        if ext_mod.include?(Flapjack::Gateways::Thin)
-
-          unless @thin_silenced
-            Thin::Logging.silent = true
-            @thin_silenced = true
-          end
+      remove_pikelets(removed_pikelets)
 
-          pikelet = Thin::Server.new('0.0.0.0',
-                      pikelet_class.instance_variable_get('@port'),
-                      pikelet_class, :signals => false)
+      # 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) }
 
-        elsif ext_mod.include?(Flapjack::Gateways::Resque)
+      # puts "added pikelet configs"
+      # p added_pikelets
 
-          # set up connection pooling, stop resque errors
-          unless @resque_pool
-            @resque_pool = Flapjack::RedisPool.new(:config => @redis_options)
-            ::Resque.redis = @resque_pool
-            ## NB: can override the default 'resque' namespace like this
-            #::Resque.redis.namespace = 'flapjack'
-          end
-
-          # TODO error if pikelet_cfg['queue'].nil?
-          pikelet = EM::Resque::Worker.new(pikelet_cfg['queue'])
-          # # Use these to debug the resque workers
-          # pikelet.verbose = true
-          # pikelet.very_verbose = true
-        end
-
-      end
+      add_pikelets(added_pikelets)
+    end
 
-      pikelet_info = {:class => pikelet_class, :instance => pikelet}
-
-      if inc_mod.include?(Flapjack::GenericPikelet) ||
-        ext_mod.include?(Flapjack::Gateways::Resque)
-
-        fiber = Fiber.new {
-          begin
-            # Can't use local inc_mod/ext_mod variables in the new fiber
-            if pikelet.is_a?(Flapjack::GenericPikelet)
-              pikelet.main
-            elsif extended_modules(pikelet_class).include?(Flapjack::Gateways::Resque)
-              pikelet.work(0.1)
-            end
-          rescue Exception => e
-            trace = e.backtrace.join("\n")
-            @logger.fatal "#{e.message}\n#{trace}"
-            stop
-          end
-        }
+  private
 
-        pikelet_info[:fiber] = fiber
-        fiber.resume
-        @logger.debug "new fiber created for #{pikelet_class}"
-      elsif ext_mod.include?(Flapjack::Gateways::Thin)
-        pikelet.start
-        @logger.debug "new thin server instance started for #{pikelet_class}"
+    # 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 }
+      Kernel.trap('TERM') { stop }
+      unless RbConfig::CONFIG['host_os'] =~ /mswin|windows|cygwin/i
+        Kernel.trap('QUIT') { stop }
+        Kernel.trap('HUP')  { reload }
       end
-
-      @pikelets << pikelet_info
     end
 
-    # only prints state changes, otherwise pikelets not closing promptly can
-    # cause everything else to be spammy
-    def health_check
-      @pikelets.each do |pik|
-        status = if extended_modules(pik[:class]).include?(Flapjack::Gateways::Thin)
-          pik[:instance].backend.size > 0 ? 'running' : 'stopped'
-        elsif pik[:fiber]
-          pik[:fiber].alive? ? 'running' : 'stopped'
-        end
-        next if pik.has_key?(:status) && pik[:status].eql?(status)
-        @logger.info "#{pik[:class].name}: #{status}"
-        pik[:status] = status
+    # passed a hash with {PIKELET_TYPE => PIKELET_CFG, ...}
+    def add_pikelets(pikelets_data = {})
+      pikelets_data.each_pair do |type, cfg|
+        next unless pikelet = Flapjack::Pikelet.create(type,
+          :config => cfg, :redis_config => @redis_options)
+        @pikelets << pikelet
+        pikelet.start
       end
     end
 
-    def shutdown
-      @pikelets.each do |pik|
-
-        pik_inst = pik[:instance]
-        ext_mod  = extended_modules(pik[:class])
-
-        # would be neater if we could use something similar for the class << self
-        # included pikelets as well
-        if pik_inst.is_a?(Flapjack::GenericPikelet)
-          if pik[:fiber] && pik[:fiber].alive?
-            pik_inst.stop
-            Fiber.new {
-              # this needs to use a separate Redis connection from the pikelet's
-              # one, as that's in the middle of its blpop
-              r = Redis.new(@redis_options.merge(:driver => 'synchrony'))
-              pik_inst.add_shutdown_event(:redis => r)
-              r.quit
-            }.resume
-          end
-        elsif ext_mod.include?(Flapjack::Gateways::Resque)
-          # resque is polling, so we don't need a shutdown object
-          pik_inst.shutdown if pik[:fiber] && pik[:fiber].alive?
-        elsif ext_mod.include?(Flapjack::Gateways::Thin)
-          # drop from this side, as HTTP keepalive etc. means browsers
-          # keep connections alive for ages, and we'd be hanging around
-          # waiting for them to drop
-          pik_inst.stop!
-        end
-      end
-
+    def remove_pikelets(piks, opts = {})
       Fiber.new {
+        piks.map(&:stop)
 
         loop do
-          health_check
+          # 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 @pikelets.any? {|p| p[:status] == 'running'}
+          if piks.any? {|p| p.status == 'stopping' }
             EM::Synchrony.sleep 0.25
           else
-            @resque_pool.empty! if @resque_pool
-
-            @pikelets.each do |pik|
-
-              pik_inst = pik[:instance]
-              ext_mod = extended_modules(pik[:class])
-
-              if pik_inst.is_a?(Flapjack::GenericPikelet)
-
-                pik_inst.cleanup
-
-              elsif [Flapjack::Gateways::Resque, Flapjack::Gateways::Thin].any?{|fp|
-                ext_mod.include?(fp)
-              }
-
-                pik[:class].cleanup
-
-              end
-            end
-
-            EM.stop
+            EM.stop if opts[:shutdown]
+            @pikelets -= piks
             break
           end
         end
       }.resume
     end
 
-    def extended_modules(klass)
-      (class << klass; self; end).included_modules
-    end
-
-    PIKELET_TYPES = {'executive'  => Flapjack::Executive}
-
-    GATEWAY_TYPES = {'web'        => Flapjack::Gateways::Web,
-                     'api'        => Flapjack::Gateways::API,
-                     'jabber'     => Flapjack::Gateways::Jabber,
-                     'pagerduty'  => Flapjack::Gateways::Pagerduty,
-                     'oobetet'    => Flapjack::Gateways::Oobetet,
-                     'email'      => Flapjack::Gateways::Email,
-                     'sms'        => Flapjack::Gateways::SmsMessagenet}
-
-
     def pikelets(config_env)
       return {} unless config_env
-      config_env.inject({}) {|memo, (k, v)|
-        if klass = PIKELET_TYPES[k]
-          memo[klass] = v
-        end
-        memo
-      }
-    end
-
-    def gateways(config_env)
-      return {} unless config_env && config_env['gateways'] &&
+      exec_cfg = config_env.has_key?('executive') && config_env['executive']['enabled'] ?
+        {'executive' => config_env['executive']} :
+        {}
+      return exec_cfg unless config_env && config_env['gateways'] &&
         !config_env['gateways'].nil?
-      config_env['gateways'].inject({}) {|memo, (k, v)|
-        if klass = GATEWAY_TYPES[k]
-          memo[klass] = v
-        end
-        memo
-      }
+      exec_cfg.merge( config_env['gateways'].select {|k, v|
+        Flapjack::Pikelet.is_pikelet?(k) && v['enabled']
+      } )
     end
 
   end