flapjack 0.7.18 → 0.7.19

data/lib/flapjack/patches.rb

@@ -1,48 +1,8 @@
 #!/usr/bin/env ruby
 
-require 'ostruct'
 require 'thin'
 require 'resque'
-# require 'log4r'
-
-class OpenStruct
-  def to_h
-    @table
-  end
-end
-
-#module Log4r
-#  class Logger
-#    def error(args)
-#      err(args)
-#    end
-#
-#    def warning(args)
-#      warn(args)
-#    end
-#  end
-#end
-
-# extracted from Extlib.
-# FIXME: what's the licensing here?
-class String
-  def camel_case
-    return self if self !~ /_/ && self =~ /[A-Z]+.*/
-    split('_').map{|e| e.capitalize}.join
-  end
-end
-
-# http://gist.github.com/151324
-class Hash
-  def symbolize_keys
-    inject({}) do |acc, (k,v)|
-      key = String === k ? k.to_sym : k
-      value = Hash === v ? v.symbolize_keys : v
-      acc[key] = value
-      acc
-    end
-  end
-end
+require 'redis'
 
 # we don't want to stop the entire EM reactor when we stop a web server
 # & @connections data type changed in thin 1.5.1

data/lib/flapjack/pikelet.rb

@@ -17,7 +17,8 @@ require 'em-resque'
 require 'em-resque/worker'
 require 'thin'
 
-require 'flapjack/executive'
+require 'flapjack/notifier'
+require 'flapjack/processor'
 require 'flapjack/gateways/api'
 require 'flapjack/gateways/jabber'
 require 'flapjack/gateways/oobetet'
@@ -94,7 +95,8 @@ module Flapjack
 
     class Generic < Flapjack::Pikelet::Base
 
-     PIKELET_TYPES = {'executive'  => Flapjack::Executive,
+     PIKELET_TYPES = {'notifier'   => Flapjack::Notifier,
+                      'processor'  => Flapjack::Processor,
                       'jabber'     => Flapjack::Gateways::Jabber,
                       'pagerduty'  => Flapjack::Gateways::Pagerduty,
                       'oobetet'    => Flapjack::Gateways::Oobetet}

data/lib/flapjack/{executive.rb → processor.rb}

@@ -1,11 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'log4r'
-require 'log4r/outputter/fileoutputter'
-require 'tzinfo'
-require 'active_support/time'
-
-require 'chronic'
 require 'chronic_duration'
 
 require 'flapjack/filters/acknowledgement'
@@ -14,19 +8,15 @@ require 'flapjack/filters/scheduled_maintenance'
 require 'flapjack/filters/unscheduled_maintenance'
 require 'flapjack/filters/detect_mass_client_failures'
 require 'flapjack/filters/delays'
-require 'flapjack/data/contact'
+
 require 'flapjack/data/entity_check'
-require 'flapjack/data/notification'
 require 'flapjack/data/event'
 require 'flapjack/redis_pool'
 require 'flapjack/utility'
 
-require 'flapjack/gateways/email'
-require 'flapjack/gateways/sms_messagenet'
-
 module Flapjack
 
-  class Executive
+  class Processor
 
     include Flapjack::Utility
 
@@ -36,29 +26,9 @@ module Flapjack
       @logger = opts[:logger]
       @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2) # first will block
 
-      @queues = {:email     => @config['email_queue'],
-                 :sms       => @config['sms_queue'],
-                 :jabber    => @config['jabber_queue'],
-                 :pagerduty => @config['pagerduty_queue']}
+      @queue = @config['queue'] || 'events'
 
-      notifylog  = @config['notification_log_file'] || 'log/notify.log'
-      if not File.directory?(File.dirname(notifylog))
-        puts "Parent directory for log file #{notifylog} doesn't exist"
-        puts "Exiting!"
-        exit
-      end
-      @notifylog = Log4r::Logger.new("executive")
-      @notifylog.add(Log4r::FileOutputter.new("notifylog", :filename => notifylog))
-
-      tz = nil
-      tz_string = @config['default_contact_timezone'] || ENV['TZ'] || 'UTC'
-      begin
-        tz = ActiveSupport::TimeZone.new(tz_string)
-      rescue ArgumentError
-        logger.error("Invalid timezone string specified in default_contact_timezone or TZ (#{tz_string})")
-        exit 1
-      end
-      @default_contact_timezone = tz
+      @notifier_queue = @config['notifier_queue'] || 'notifications'
 
       @archive_events        = @config['archive_events'] || false
       @events_archive_maxage = @config['events_archive_maxage']
@@ -66,8 +36,6 @@ module Flapjack
       ncsm_duration_conf = @config['new_check_scheduled_maintenance_duration'] || '100 years'
       @ncsm_duration = ChronicDuration.parse(ncsm_duration_conf)
 
-      # FIXME: Put loading filters into separate method
-      # FIXME: should we make the filters more configurable by the end user?
       options = { :logger => opts[:logger], :redis => @redis }
       @filters = []
       @filters << Flapjack::Filters::Ok.new(options)
@@ -77,10 +45,10 @@ module Flapjack
       @filters << Flapjack::Filters::Delays.new(options)
       @filters << Flapjack::Filters::Acknowledgement.new(options)
 
-      @boot_time    = opts[:boot_time]
-      @fqdn         = `/bin/hostname -f`.chomp
-      @pid          = Process.pid
-      @instance_id  = "#{@fqdn}:#{@pid}"
+      boot_time     = opts[:boot_time]
+      fqdn          = `/bin/hostname -f`.chomp
+      pid           = Process.pid
+      @instance_id  = "#{fqdn}:#{pid}"
 
       # FIXME: all of the below keys assume there is only ever one executive running;
       # we could generate a fuid and save it to disk, and prepend it from that
@@ -94,8 +62,8 @@ module Flapjack
         @redis.hset('event_counters', 'action', 0)
       end
 
-      #@redis.zadd('executive_instances', @boot_time.to_i, @instance_id)
-      @redis.hset("executive_instance:#{@instance_id}", 'boot_time', @boot_time.to_i)
+      #@redis.zadd('executive_instances', boot_time.to_i, @instance_id)
+      @redis.hset("executive_instance:#{@instance_id}", 'boot_time', boot_time.to_i)
       @redis.hset("event_counters:#{@instance_id}", 'all', 0)
       @redis.hset("event_counters:#{@instance_id}", 'ok', 0)
       @redis.hset("event_counters:#{@instance_id}", 'failure', 0)
@@ -122,7 +90,8 @@ module Flapjack
 
       until @should_quit
         @logger.debug("Waiting for event...")
-        event = Flapjack::Data::Event.next(:redis => @redis,
+        event = Flapjack::Data::Event.next(@queue,
+                                           :redis => @redis,
                                            :archive_events => @archive_events,
                                            :events_archive_maxage => @events_archive_maxage,
                                            :logger => @logger)
@@ -136,10 +105,10 @@ module Flapjack
     # from a different fiber while the main one is blocking.
     def stop
       @should_quit = true
-      @redis.rpush('events', JSON.generate('type'    => 'shutdown',
-                                           'host'    => '',
-                                           'service' => '',
-                                           'state'   => ''))
+      @redis.rpush('events', Oj.dump('type'    => 'shutdown',
+                                     'host'    => '',
+                                     'service' => '',
+                                     'state'   => ''))
     end
 
   private
@@ -160,15 +129,15 @@ module Flapjack
       should_notify = update_keys(event, entity_check, timestamp)
 
       if !should_notify
-        @logger.debug("Not generating notifications for event #{event.id} because filtering was skipped")
+        @logger.debug("Not generating notification for event #{event.id} because filtering was skipped")
         return
       elsif blocker = @filters.find {|filter| filter.block?(event) }
-        @logger.debug("Not generating notifications for event #{event.id} because this filter blocked: #{blocker.name}")
+        @logger.debug("Not generating notification for event #{event.id} because this filter blocked: #{blocker.name}")
         return
       end
 
-      @logger.info("Generating notifications for event #{event_str}")
-      generate_notification_messages(event, entity_check, timestamp)
+      @logger.info("Generating notification for event #{event_str}")
+      generate_notification(event, entity_check, timestamp)
     end
 
     def update_keys(event, entity_check, timestamp)
@@ -177,7 +146,7 @@ module Flapjack
 
       result = true
 
-      @event_count = @redis.hincrby('event_counters', 'all', 1)
+      event.counter = @redis.hincrby('event_counters', 'all', 1)
       @redis.hincrby("event_counters:#{@instance_id}", 'all', 1)
 
       # FIXME skip if entity_check.nil?
@@ -197,7 +166,7 @@ module Flapjack
         elsif event.failure?
           @redis.hincrby('event_counters', 'failure', 1)
           @redis.hincrby("event_counters:#{@instance_id}", 'failure', 1)
-          @redis.hset('unacknowledged_failures', @event_count, event.id)
+          @redis.hset('unacknowledged_failures', event.counter, event.id)
         end
 
         event.previous_state = entity_check.state
@@ -207,8 +176,8 @@ module Flapjack
 
           if @ncsm_duration >= 0
             @logger.info("Setting scheduled maintenance for #{time_period_in_words(@ncsm_duration)}")
-            entity_check.create_scheduled_maintenance(:start_time => timestamp,
-              :duration => @ncsm_duration, :summary => 'Automatically created for new check')
+            entity_check.create_scheduled_maintenance(timestamp,
+              @ncsm_duration, :summary => 'Automatically created for new check')
           end
         else
           event.previous_state_duration = timestamp - entity_check.last_change.to_i
@@ -216,7 +185,7 @@ module Flapjack
 
         entity_check.update_state(event.state, :timestamp => timestamp,
           :summary => event.summary, :client => event.client,
-          :count => @event_count, :details => event.details)
+          :count => event.counter, :details => event.details)
 
         # No state change, and event is ok, so no need to run through filters
         # OR
@@ -244,27 +213,8 @@ module Flapjack
       result
     end
 
-    # takes an event for which a notification needs to be generated, works out the type of
-    # notification, updates the notification history in redis, generates the notifications
-    def generate_notification_messages(event, entity_check, timestamp)
-      notification_type = 'unknown'
-      case event.type
-      when 'service'
-        case event.state
-        when 'ok'
-          notification_type = 'recovery'
-        when 'warning', 'critical', 'unknown'
-          notification_type = 'problem'
-        end
-      when 'action'
-        case event.state
-        when 'acknowledgement'
-          notification_type = 'acknowledgement'
-        when 'test_notifications'
-          notification_type = 'test'
-        end
-      end
-
+    def generate_notification(event, entity_check, timestamp)
+      notification_type = Flapjack::Data::Notification.type_for_event(event)
       max_notified_severity = entity_check.max_notified_severity_of_current_failure
 
       @redis.set("#{event.id}:last_#{notification_type}_notification", timestamp)
@@ -273,75 +223,12 @@ module Flapjack
       @redis.rpush("#{event.id}:#{event.state}_notifications", timestamp) if event.failure?
       @logger.debug("Notification of type #{notification_type} is being generated for #{event.id}.")
 
-      contacts = entity_check.contacts
+      severity = Flapjack::Data::Notification.severity_for_event(event, max_notified_severity)
+      last_state = entity_check.historical_state_before(timestamp)
 
-      if contacts.empty?
-        @logger.debug("No contacts for #{event.id}")
-        @notifylog.info("#{Time.at(timestamp).to_s} | #{event.id} | #{notification_type} | NO CONTACTS")
-        return
-      end
-
-      notification = Flapjack::Data::Notification.for_event(
-        event, :type => notification_type,
-               :max_notified_severity => max_notified_severity,
-               :contacts => contacts,
-               :default_timezone => @default_contact_timezone,
-               :last_state => entity_check.historical_state_before(timestamp),
-               :logger => @logger)
-
-      notification.messages.each do |message|
-        media_type = message.medium
-        contents   = message.contents
-        address    = message.address
-        event_id   = event.id
-
-        @notifylog.info("#{Time.at(timestamp).to_s} | #{event_id} | " +
-          "#{notification_type} | #{message.contact.id} | #{media_type} | #{address}")
-
-        unless @queues[media_type.to_sym]
-          @logger.error("no queue for media type: #{media_type}")
-          return
-        end
-
-        @logger.info("Enqueueing #{media_type} alert for #{event_id} to #{address}")
-
-        if event.ok?
-          message.contact.update_sent_alert_keys(
-            :media => media_type,
-            :check => event_id,
-            :state => 'warning',
-            :delete => true)
-          message.contact.update_sent_alert_keys(
-            :media => media_type,
-            :check => event_id,
-            :state => 'critical',
-            :delete => true)
-          message.contact.update_sent_alert_keys(
-            :media => media_type,
-            :check => event_id,
-            :state => 'unknown',
-            :delete => true)
-        else
-          message.contact.update_sent_alert_keys(
-            :media => media_type,
-            :check => event_id,
-            :state => event.state)
-        end
-
-        # TODO consider changing Resque jobs to use raw blpop like the others
-        case media_type.to_sym
-        when :sms
-          Resque.enqueue_to(@queues[:sms], Flapjack::Gateways::SmsMessagenet, contents)
-        when :email
-          Resque.enqueue_to(@queues[:email], Flapjack::Gateways::Email, contents)
-        when :jabber
-          # TODO move next line up into other notif value setting above?
-          contents['event_count'] = @event_count if @event_count
-          @redis.rpush(@queues[:jabber], Yajl::Encoder.encode(contents))
-        when :pagerduty
-          @redis.rpush(@queues[:pagerduty], Yajl::Encoder.encode(contents))
-        end
-      end
+      Flapjack::Data::Notification.add(@notifier_queue, event,
+        :type => notification_type, :severity => severity, :last_state => last_state,
+        :redis => @redis)
     end
 
   end

data/lib/flapjack/version.rb

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

data/spec/lib/flapjack/coordinator_spec.rb

@@ -7,91 +7,154 @@ describe Flapjack::Coordinator do
   let(:fiber)  { mock(Fiber) }
   let(:config) { mock(Flapjack::Configuration) }
 
-  let(:logger)     { mock(Logger) }
-  let(:stdout_out) { mock('stdout_out') }
-  let(:syslog_out) { mock('syslog_out') }
+  let(:logger)     { mock(Flapjack::Logger) }
 
   let!(:time)   { Time.now }
 
-  def setup_logger
-    formatter = mock('Formatter')
-    Log4r::PatternFormatter.should_receive(:new).with(
-      :pattern => "%d [%l] :: flapjack-coordinator :: %m",
-      :date_pattern => "%Y-%m-%dT%H:%M:%S%z").and_return(formatter)
+  it "starts and stops a pikelet" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+
+    cfg = {'processor' => {'enabled' => true}}
+    EM.should_receive(:synchrony).and_yield
+    config.should_receive(:for_redis).and_return({})
+    config.should_receive(:all).and_return(cfg)
+
+    processor = mock('processor')
+    processor.should_receive(:start)
+    processor.should_receive(:stop)
+    processor.should_receive(:update_status)
+    processor.should_receive(:status).exactly(3).times.and_return('stopped')
 
-    stdout_out.should_receive(:formatter=).with(formatter)
-    syslog_out.should_receive(:formatter=).with(formatter)
+    Time.should_receive(:now).and_return(time)
+
+    fc = Flapjack::Coordinator.new(config)
+    Flapjack::Pikelet.should_receive(:create).with('processor',
+        :config => cfg['processor'], :redis_config => {}, :boot_time => time).
+      and_return(processor)
+
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    Log4r::StdoutOutputter.should_receive(:new).and_return(stdout_out)
-    Log4r::SyslogOutputter.should_receive(:new).and_return(syslog_out)
-    logger.should_receive(:add).with(stdout_out)
-    logger.should_receive(:add).with(syslog_out)
-    Log4r::Logger.should_receive(:new).and_return(logger)
+    EM.should_receive(:stop)
+
+    # Syslog.should_receive(:opened?).and_return(true)
+    # Syslog.should_receive(:close)
+
+    fc.start(:signals => false)
+    fc.stop
   end
 
-  it "starts and stops a pikelet" do
-    setup_logger
+  it "handles an exception raised by a pikelet and shuts down" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+    logger.should_receive(:fatal)
 
-    cfg = {'executive' => {'enabled' => 'yes'}}
+    cfg = {'processor' => {'enabled' => true}}
     EM.should_receive(:synchrony).and_yield
     config.should_receive(:for_redis).and_return({})
     config.should_receive(:all).and_return(cfg)
 
-    executive = mock('executive')
-    executive.should_receive(:start)
-    executive.should_receive(:stop)
-    executive.should_receive(:update_status)
-    executive.should_receive(:status).exactly(3).times.and_return('stopped')
+    processor = mock('processor')
+    processor.should_receive(:start).and_raise(RuntimeError)
+    processor.should_receive(:stop)
+    processor.should_receive(:update_status)
+    processor.should_receive(:status).exactly(3).times.and_return('stopped')
 
     Time.should_receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    Flapjack::Pikelet.should_receive(:create).with('executive',
-        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
-      and_return(executive)
+    Flapjack::Pikelet.should_receive(:create).with('processor',
+        :config => cfg['processor'], :redis_config => {}, :boot_time => time)
+      .and_return(processor)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
     EM.should_receive(:stop)
 
+    # Syslog.should_receive(:opened?).and_return(true)
+    # Syslog.should_receive(:close)
+
     fc.start(:signals => false)
     fc.stop
   end
 
-  it "handles an exception raised by a pikelet and shuts down" do
-    setup_logger
-    logger.should_receive(:fatal)
+  it "loads an old executive pikelet config block with no new data" do
+    cfg = {'executive' => {'enabled' => true}}
+    EM.should_receive(:synchrony).and_yield
+    config.should_receive(:for_redis).and_return({})
+    config.should_receive(:all).and_return(cfg)
+
+    processor = mock('processor')
+    processor.should_receive(:start)
+    processor.should_receive(:stop)
+    processor.should_receive(:update_status)
+    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+
+    notifier = mock('processor')
+    notifier.should_receive(:start)
+    notifier.should_receive(:stop)
+    notifier.should_receive(:update_status)
+    notifier.should_receive(:status).exactly(3).times.and_return('stopped')
+
+    Time.should_receive(:now).and_return(time)
+
+    fc = Flapjack::Coordinator.new(config)
+    Flapjack::Pikelet.should_receive(:create).with('processor',
+        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
+      and_return(processor)
+    Flapjack::Pikelet.should_receive(:create).with('notifier',
+        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
+      and_return(notifier)
 
-    cfg = {'executive' => {'enabled' => 'yes'}}
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
+
+    EM.should_receive(:stop)
+
+    # Syslog.should_receive(:opened?).and_return(true)
+    # Syslog.should_receive(:close)
+
+    fc.start(:signals => false)
+    fc.stop
+  end
+
+  it "loads an old executive pikelet config block with some new data" do
+    cfg = {'executive' => {'enabled' => true},
+           'processor' => {'foo' => 'bar'},
+           'notifier'  => {'enabled' => false}
+          }
     EM.should_receive(:synchrony).and_yield
     config.should_receive(:for_redis).and_return({})
     config.should_receive(:all).and_return(cfg)
 
-    executive = mock('executive')
-    executive.should_receive(:start).and_raise(RuntimeError)
-    executive.should_receive(:stop)
-    executive.should_receive(:update_status)
-    executive.should_receive(:status).exactly(3).times.and_return('stopped')
+    processor = mock('processor')
+    processor.should_receive(:start)
+    processor.should_receive(:stop)
+    processor.should_receive(:update_status)
+    processor.should_receive(:status).exactly(3).times.and_return('stopped')
 
     Time.should_receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    Flapjack::Pikelet.should_receive(:create).with('executive',
-        :config => cfg['executive'], :redis_config => {}, :boot_time => time)
-      .and_return(executive)
+    Flapjack::Pikelet.should_receive(:create).with('processor',
+        :config => cfg['executive'].merge(cfg['processor']),
+        :redis_config => {}, :boot_time => time).
+      and_return(processor)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
     EM.should_receive(:stop)
 
+    # Syslog.should_receive(:opened?).and_return(true)
+    # Syslog.should_receive(:close)
+
     fc.start(:signals => false)
     fc.stop
   end
 
   it "traps system signals and shuts down" do
-    setup_logger
+    Flapjack::Logger.should_receive(:new).and_return(logger)
 
     RbConfig::CONFIG.should_receive(:[]).with('host_os').and_return('darwin12.0.0')
 
@@ -109,7 +172,7 @@ describe Flapjack::Coordinator do
   end
 
   it "only traps two system signals on Windows" do
-    setup_logger
+    Flapjack::Logger.should_receive(:new).and_return(logger)
 
     RbConfig::CONFIG.should_receive(:[]).with('host_os').and_return('mswin')
 
@@ -126,10 +189,10 @@ describe Flapjack::Coordinator do
   end
 
   it "stops one pikelet and starts another on reload" do
-    setup_logger
+    Flapjack::Logger.should_receive(:new).and_return(logger)
 
-    old_cfg = {'executive' => {'enabled' => 'yes'}}
-    new_cfg = {'gateways' => {'jabber' => {'enabled' => 'yes'}}}
+    old_cfg = {'processor' => {'enabled' => true}}
+    new_cfg = {'gateways' => {'jabber' => {'enabled' => true}}}
 
     new_config = mock('new_config')
     filename = mock('filename')
@@ -141,15 +204,15 @@ describe Flapjack::Coordinator do
     new_config.should_receive(:load).with(filename)
     new_config.should_receive(:all).and_return(new_cfg)
 
-    executive = mock('executive')
-    executive.should_receive(:type).twice.and_return('executive')
-    executive.should_receive(:stop)
-    executive.should_receive(:update_status)
-    executive.should_receive(:status).exactly(3).times.and_return('stopped')
+    processor = mock('processor')
+    processor.should_receive(:type).twice.and_return('processor')
+    processor.should_receive(:stop)
+    processor.should_receive(:update_status)
+    processor.should_receive(:status).exactly(3).times.and_return('stopped')
 
     jabber = mock('jabber')
     Flapjack::Pikelet.should_receive(:create).
-      with('jabber', :config => {"enabled" => "yes"}, :redis_config => {},
+      with('jabber', :config => {"enabled" => true}, :redis_config => {},
         :boot_time => time).
       and_return(jabber)
     jabber.should_receive(:start)
@@ -160,16 +223,16 @@ describe Flapjack::Coordinator do
     config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@boot_time', time)
-    fc.instance_variable_set('@pikelets', [executive])
+    fc.instance_variable_set('@pikelets', [processor])
     fc.reload
     fc.instance_variable_get('@pikelets').should == [jabber]
   end
 
   it "reloads a pikelet config without restarting it" do
-    setup_logger
+    Flapjack::Logger.should_receive(:new).and_return(logger)
 
-    old_cfg = {'executive' => {'enabled' => 'yes', 'foo' => 'bar'}}
-    new_cfg = {'executive' => {'enabled' => 'yes', 'foo' => 'baz'}}
+    old_cfg = {'processor' => {'enabled' => true, 'foo' => 'bar'}}
+    new_cfg = {'processor' => {'enabled' => true, 'foo' => 'baz'}}
 
     new_config = mock('new_config')
     filename = mock('filename')
@@ -181,25 +244,25 @@ describe Flapjack::Coordinator do
     new_config.should_receive(:load).with(filename)
     new_config.should_receive(:all).and_return(new_cfg)
 
-    executive = mock('executive')
-    executive.should_not_receive(:start)
-    executive.should_receive(:type).exactly(3).times.and_return('executive')
-    executive.should_receive(:reload).with(new_cfg['executive']).and_return(true)
-    executive.should_not_receive(:stop)
+    processor = mock('processor')
+    processor.should_not_receive(:start)
+    processor.should_receive(:type).exactly(3).times.and_return('processor')
+    processor.should_receive(:reload).with(new_cfg['processor']).and_return(true)
+    processor.should_not_receive(:stop)
 
     config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@boot_time', time)
-    fc.instance_variable_set('@pikelets', [executive])
+    fc.instance_variable_set('@pikelets', [processor])
     fc.reload
-    fc.instance_variable_get('@pikelets').should == [executive]
+    fc.instance_variable_get('@pikelets').should == [processor]
   end
 
   it "reloads a pikelet config while restarting it" do
-    setup_logger
+    Flapjack::Logger.should_receive(:new).and_return(logger)
 
-    old_cfg = {'executive' => {'enabled' => 'yes', 'foo' => 'bar'}}
-    new_cfg = {'executive' => {'enabled' => 'yes', 'baz' => 'qux'}}
+    old_cfg = {'processor' => {'enabled' => true, 'foo' => 'bar'}}
+    new_cfg = {'processor' => {'enabled' => true, 'baz' => 'qux'}}
 
     new_config = mock('new_config')
     filename = mock('filename')
@@ -211,12 +274,12 @@ describe Flapjack::Coordinator do
     new_config.should_receive(:load).with(filename)
     new_config.should_receive(:all).and_return(new_cfg)
 
-    executive = mock('executive')
-    executive.should_receive(:type).exactly(5).times.and_return('executive')
-    executive.should_receive(:reload).with(new_cfg['executive']).and_return(false)
-    executive.should_receive(:stop)
-    executive.should_receive(:update_status)
-    executive.should_receive(:status).exactly(3).times.and_return('stopped')
+    processor = mock('processor')
+    processor.should_receive(:type).exactly(5).times.and_return('processor')
+    processor.should_receive(:reload).with(new_cfg['processor']).and_return(false)
+    processor.should_receive(:stop)
+    processor.should_receive(:update_status)
+    processor.should_receive(:status).exactly(3).times.and_return('stopped')
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
@@ -225,14 +288,14 @@ describe Flapjack::Coordinator do
     new_exec.should_receive(:start)
 
     Flapjack::Pikelet.should_receive(:create).
-      with('executive', :config => new_cfg['executive'], :redis_config => {},
+      with('processor', :config => new_cfg['processor'], :redis_config => {},
         :boot_time => time).
       and_return(new_exec)
 
     config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@boot_time', time)
-    fc.instance_variable_set('@pikelets', [executive])
+    fc.instance_variable_set('@pikelets', [processor])
     fc.reload
     fc.instance_variable_get('@pikelets').should == [new_exec]
   end