flapjack 1.6.0 → 2.0.0b1

data/spec/lib/flapjack/configuration_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+require 'flapjack/configuration'
+
+describe Flapjack::Configuration, :logger => true do
+
+  let(:configuration) { Flapjack::Configuration.new }
+
+  # NOTE For readability, config files are defined at the bottom of this spec
+
+  context "single config file" do
+
+    before(:each) do
+      allow(Dir).to receive(:glob).and_return(%w(dummy_file))
+      expect(File).to receive(:read).and_return(toml_data)
+      configuration.load('dummy_path')
+    end
+
+    describe "redis configuration data" do
+      it "loads data accessible by symbol" do
+        expect(configuration.for_redis[:host]).to eq('192.168.0.1')
+        expect(configuration.for_redis[:port]).to eq(9999)
+        expect(configuration.for_redis[:db]).to eq(11)
+      end
+
+      it "loads data accessible by string" do
+        expect(configuration.for_redis['host']).to eq('192.168.0.1')
+        expect(configuration.for_redis['port']).to eq(9999)
+        expect(configuration.for_redis['db']).to eq(11)
+      end
+    end
+
+    describe "all configuration data" do
+      it "loads data accessible by symbol" do
+        expect(configuration.all[:processor][:enabled]).to be_a(TrueClass)
+      end
+
+      it "loads data accessible by string" do
+        expect(configuration.all['processor']['enabled']).to be_a(TrueClass)
+      end
+
+      it "loads nested data" do
+        expect(
+          configuration.all[:gateways][:sms_twilio][:logger][:syslog_errors]
+        ).to be_a(TrueClass)
+      end
+    end
+
+    describe "reload configuration data" do
+
+      it "reloads config data" do
+        allow(File).to receive(:read).and_return(reloaded_toml_data)
+
+        expect(configuration.for_redis[:host]).to eq('192.168.0.1')
+        expect(configuration.for_redis[:port]).to eq(9999)
+        expect(configuration.for_redis[:db]).to eq(11)
+
+        configuration.reload
+
+        expect(configuration.for_redis['host']).to eq('192.168.0.2')
+        expect(configuration.for_redis['port']).to eq(8888)
+        expect(configuration.for_redis['db']).to eq(12)
+
+        expect(configuration.all['processor']).to be_nil
+      end
+    end
+  end
+
+  context "multiple config files" do
+
+    it "loads config data from files" do
+      expect(Dir).to receive(:glob).and_return(%w(1 2 3))
+      expect(File).to receive(:read).thrice.and_return(
+        base_toml_data,
+        redis_toml_data,
+        gateways_sms_toml_data
+        )
+
+      configuration.load('dummy_pattern')
+
+      expect(configuration.all[:gateways][:sms][:enabled]).to be_a(FalseClass)
+      expect(configuration.for_redis[:host]).to eq('192.168.0.1')
+    end
+
+    it "fails to load config from clashing files" do
+      expect(Dir).to receive(:glob).and_return(%w(1 2 3))
+      expect(File).to receive(:read).thrice.and_return(
+        base_toml_data,
+        redis_toml_data,
+        clashing_redis_toml_data
+        )
+
+      configuration.load('dummy_pattern')
+
+      expect(configuration.all).to be_nil
+    end
+  end
+
+  let(:toml_data) {
+    <<-TOML_DATA
+[logger]
+  level = "INFO"
+  syslog_errors = true
+[redis]
+  host = "192.168.0.1"
+  port = 9999
+  db = 11
+[processor]
+  enabled = true
+  queue = "events"
+  notifier_queue = "notifications"
+  archive_events = true
+  events_archive_maxage = 10800
+  new_check_scheduled_maintenance_duration = "100 years"
+  new_check_scheduled_maintenance_ignore_regex = "bypass_ncsm$"
+  [processor.logger]
+    level = "INFO"
+    syslog_errors = true
+[notifier]
+  enabled = true
+  queue = "notifications"
+  email_queue = "email_notifications"
+  sms_queue = "sms_notifications"
+  sms_twilio_queue = "sms_twilio_notifications"
+  sns_queue = "sns_notifications"
+  jabber_queue = "jabber_notifications"
+  pagerduty_queue = "pagerduty_notifications"
+  default_contact_timezone = "UTC"
+  [notifier.logger]
+    level = "INFO"
+    syslog_errors = true
+[nagios-receiver]
+  fifo = "/var/cache/nagios3/event_stream.fifo"
+[nsca-receiver]
+  fifo = "/var/lib/nagios3/rw/nagios.cmd"
+[gateways]
+  # Generates email notifications
+  [gateways.email]
+    enabled = false
+    queue = "email_notifications"
+    [gateways.email.logger]
+      level = "INFO"
+      syslog_errors = true
+    [gateways.email.smtp_config]
+      host = "127.0.0.1"
+      port = 1025
+      starttls = false
+  [gateways.sms]
+    enabled = false
+    queue = "sms_notifications"
+    endpoint = "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage"
+    username = "ermahgerd"
+    password = "xxxx"
+    [gateways.sms.logger]
+      level = "INFO"
+      syslog_errors = true
+  [gateways.sms_twilio]
+    enabled = false
+    queue = "sms_twilio_notifications"
+    account_sid = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    auth_token = "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy"
+    from = "+1xxxxxxxxxx"
+    [gateways.sms_twilio.logger]
+      level = "INFO"
+      syslog_errors = true
+  [gateways.sns]
+    enabled = false
+    queue = "sns_notifications"
+    access_key = "AKIAIOSFODNN7EXAMPLE"
+    secret_key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+  [gateways.jabber]
+    enabled = false
+    queue = "jabber_notifications"
+    server = "jabber.example.com"
+    port = 5222
+    jabberid = "flapjack@jabber.example.com"
+    password = "good-password"
+    alias = "flapjack"
+    identifiers = ["@flapjack"]
+    rooms = [
+      "gimp@conference.jabber.example.com",
+      "log@conference.jabber.example.com"
+    ]
+    [gateways.jabber.logger]
+      level = "INFO"
+      syslog_errors = true
+  [gateways.pagerduty]
+    enabled = false
+    # the redis queue this pikelet will look for notifications on
+    queue = "pagerduty_notifications"
+    [gateways.pagerduty.logger]
+      level = "INFO"
+      syslog_errors = true
+  [gateways.web]
+    enabled = true
+    port = 3080
+    timeout = 300
+    # Seconds between auto_refresh of entities/checks pages.  Set to 0 to disable
+    auto_refresh = 120
+    access_log = "/var/log/flapjack/web_access.log"
+    [gateways.web.logger]
+      level = "INFO"
+      syslog_errors = true
+  [gateways.jsonapi]
+    enabled = true
+    port = 3081
+    timeout = 300
+    access_log = "/var/log/flapjack/jsonapi_access.log"
+    base_url = "http://localhost:3081/"
+    [gateways.jsonapi.logger]
+      level = "INFO"
+      syslog_errors = true
+  [gateways.oobetet]
+    enabled = false
+    server = "jabber.example.com"
+    port = 5222
+    jabberid = "flapjacktest@jabber.example.com"
+    password = "nuther-good-password"
+    alias = "flapjacktest"
+    watched_check = "PING"
+    pagerduty_contact = 11111111111111111111111111111111
+    rooms = [
+      "flapjacktest@conference.jabber.example.com",
+      "gimp@conference.jabber.example.com",
+      "log@conference.jabber.example.com"
+    ]
+    [gateways.oobetet.logger]
+      level = "INFO"
+      syslog_errors = true
+  TOML_DATA
+  }
+
+  let(:reloaded_toml_data) {
+    <<-NEW_TOML_DATA
+daemonize = false
+[logger]
+  level = "DEBUG"
+  syslog_errors = false
+[redis]
+  host = "192.168.0.2"
+  port = 8888
+  db = 12
+NEW_TOML_DATA
+  }
+
+  let(:base_toml_data) {
+    <<-BASE_TOML_DATA
+daemonize = true
+[logger]
+  level = "INFO"
+  syslog_errors = true
+BASE_TOML_DATA
+  }
+
+  let(:redis_toml_data) {
+    <<-REDIS_TOML_DATA
+[redis]
+  host = "192.168.0.1"
+  port = 9999
+  db = 11
+REDIS_TOML_DATA
+  }
+
+  let(:clashing_redis_toml_data) {
+    <<-REDIS_TOML_DATA
+[redis]
+  host = "192.168.0.2"
+  port = 8888
+  db = 22
+REDIS_TOML_DATA
+  }
+
+  let(:gateways_sms_toml_data) {
+    <<-GATEWAYS_SMS_TOML_DATA
+[gateways.sms]
+  enabled = false
+  queue = "sms_notifications"
+  endpoint = "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage"
+  username = "ermahgerd"
+  password = "xxxx"
+  [gateways.sms.logger]
+    level = "INFO"
+    syslog_errors = true
+GATEWAYS_SMS_TOML_DATA
+  }
+end

data/spec/lib/flapjack/coordinator_spec.rb

@@ -1,127 +1,88 @@
 require 'spec_helper'
-
 require 'flapjack/coordinator'
 
 describe Flapjack::Coordinator do
 
-  let(:fiber)  { double(Fiber) }
-  let(:config) { double(Flapjack::Configuration) }
-
-  let(:logger) { double(Flapjack::Logger) }
-
-  let(:redis)  { double(::Redis) }
+  let(:config)       { double(Flapjack::Configuration) }
+  let(:redis_config) { double('redis_config')}
 
   let!(:time)  { Time.now }
 
   it "starts and stops a pikelet" do
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-
     cfg = {'processor' => {'enabled' => true}}
-    expect(EM).to receive(:synchrony).and_yield
-    expect(config).to receive(:for_redis).and_return({})
+
     expect(config).to receive(:all).twice.and_return(cfg)
 
-    expect(redis).to receive(:keys).with('entity_tag:*').and_return([])
-    expect(redis).to receive(:keys).with('check_tag:*').and_return([])
-    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(config).to receive(:for_redis).and_return(redis_config)
+    expect(Flapjack::RedisProxy).to receive(:config=).with(redis_config)
 
     processor = double('processor')
     expect(processor).to receive(:start)
     expect(processor).to receive(:stop)
-    expect(processor).to receive(:update_status)
-    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
-
-    expect(Time).to receive(:now).and_return(time)
-
-    fc = Flapjack::Coordinator.new(config)
-    expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :config => cfg['processor'], :redis_config => {}, :boot_time => time).
-      and_return(processor)
-
-    expect(EM).to receive(:stop)
-    expect(EM::Synchrony).to receive(:sleep) {
-      fc.instance_variable_set('@received_signals', ['INT'])
-    }
 
-    expect(Syslog).to receive(:opened?).and_return(true)
-    expect(Syslog).to receive(:close)
+    running_cond = double(MonitorMixin::ConditionVariable)
+    expect(running_cond).to receive(:signal)
 
-    fc.start(:signals => false)
-  end
-
-  it "handles an exception raised by a pikelet and shuts down" do
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-    expect(logger).to receive(:fatal)
-
-    cfg = {'processor' => {'enabled' => true}}
-    expect(EM).to receive(:synchrony).and_yield
-    expect(config).to receive(:for_redis).and_return({})
-    expect(config).to receive(:all).twice.and_return(cfg)
-
-    expect(redis).to receive(:keys).with('entity_tag:*').and_return([])
-    expect(redis).to receive(:keys).with('check_tag:*').and_return([])
-    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
-
-    processor = double('processor')
-    expect(processor).to receive(:start).and_raise(RuntimeError)
-    expect(processor).to receive(:stop)
-    expect(processor).to receive(:update_status)
-    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
+    monitor = double(Monitor)
+    expect(monitor).to receive(:synchronize).and_yield
+    expect(monitor).to receive(:new_cond).and_return(running_cond)
+    expect(Monitor).to receive(:new).and_return(monitor)
 
     expect(Time).to receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :config => cfg['processor'], :redis_config => {}, :boot_time => time)
-      .and_return(processor)
-
-    expect(EM).to receive(:stop)
+    expect(running_cond).to receive(:wait_until) {
+      fc.instance_variable_set('@state', :stopping)
+    }
 
-    expect(Syslog).to receive(:opened?).and_return(true)
-    expect(Syslog).to receive(:close)
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
+        an_instance_of(Proc), :config => cfg['processor'],
+        :boot_time => time).
+      and_return([processor])
 
     fc.start(:signals => false)
   end
 
   it "loads an old executive pikelet config block with no new data" do
     cfg = {'executive' => {'enabled' => true}}
-    expect(EM).to receive(:synchrony).and_yield
-    expect(config).to receive(:for_redis).and_return({})
+
     expect(config).to receive(:all).twice.and_return(cfg)
 
-    expect(redis).to receive(:keys).with('entity_tag:*').and_return([])
-    expect(redis).to receive(:keys).with('check_tag:*').and_return([])
-    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(config).to receive(:for_redis).and_return(redis_config)
+    expect(Flapjack::RedisProxy).to receive(:config=).with(redis_config)
 
     processor = double('processor')
     expect(processor).to receive(:start)
     expect(processor).to receive(:stop)
-    expect(processor).to receive(:update_status)
-    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    notifier = double('processor')
+    notifier = double('notifier')
     expect(notifier).to receive(:start)
     expect(notifier).to receive(:stop)
-    expect(notifier).to receive(:update_status)
-    expect(notifier).to receive(:status).exactly(3).times.and_return('stopped')
+
+    running_cond = double(MonitorMixin::ConditionVariable)
+    expect(running_cond).to receive(:signal)
+
+    monitor = double(Monitor)
+    expect(monitor).to receive(:synchronize).and_yield
+    expect(monitor).to receive(:new_cond).and_return(running_cond)
+    expect(Monitor).to receive(:new).and_return(monitor)
 
     expect(Time).to receive(:now).and_return(time)
 
-    fc = Flapjack::Coordinator.new(config)
-    expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :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).
-      and_return(notifier)
 
-    expect(EM).to receive(:stop)
-    expect(EM::Synchrony).to receive(:sleep) {
-      fc.instance_variable_set('@received_signals', ['INT'])
+    fc = Flapjack::Coordinator.new(config)
+    expect(running_cond).to receive(:wait_until) {
+      fc.instance_variable_set('@state', :stopping)
     }
 
-    expect(Syslog).to receive(:opened?).and_return(true)
-    expect(Syslog).to receive(:close)
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
+        an_instance_of(Proc), :config => cfg['executive'],
+        :boot_time => time).
+      and_return([processor])
+    expect(Flapjack::Pikelet).to receive(:create).with('notifier',
+        an_instance_of(Proc), :config => cfg['executive'],
+        :boot_time => time).
+      and_return([notifier])
 
     fc.start(:signals => false)
   end
@@ -131,105 +92,111 @@ describe Flapjack::Coordinator do
            'processor' => {'foo' => 'bar'},
            'notifier'  => {'enabled' => false}
           }
-    expect(EM).to receive(:synchrony).and_yield
-    expect(config).to receive(:for_redis).and_return({})
+
     expect(config).to receive(:all).twice.and_return(cfg)
 
-    expect(redis).to receive(:keys).with('entity_tag:*').and_return([])
-    expect(redis).to receive(:keys).with('check_tag:*').and_return([])
-    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(config).to receive(:for_redis).and_return(redis_config)
+    expect(Flapjack::RedisProxy).to receive(:config=).with(redis_config)
 
     processor = double('processor')
     expect(processor).to receive(:start)
     expect(processor).to receive(:stop)
-    expect(processor).to receive(:update_status)
-    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
+
+    running_cond = double(MonitorMixin::ConditionVariable)
+    expect(running_cond).to receive(:signal)
+
+    monitor = double(Monitor)
+    expect(monitor).to receive(:synchronize).and_yield
+    expect(monitor).to receive(:new_cond).and_return(running_cond)
+    expect(Monitor).to receive(:new).and_return(monitor)
 
     expect(Time).to receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    expect(Flapjack::Pikelet).to receive(:create).with('processor',
-        :config => cfg['executive'].merge(cfg['processor']),
-        :redis_config => {}, :boot_time => time).
-      and_return(processor)
-
-    expect(EM).to receive(:stop)
-    expect(EM::Synchrony).to receive(:sleep) {
-      fc.instance_variable_set('@received_signals', ['INT'])
+    expect(running_cond).to receive(:wait_until) {
+      fc.instance_variable_set('@state', :stopping)
     }
 
-    expect(Syslog).to receive(:opened?).and_return(true)
-    expect(Syslog).to receive(:close)
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
+        an_instance_of(Proc), :config => cfg['processor'].merge('enabled' => true),
+        :boot_time => time).
+      and_return([processor])
 
     fc.start(:signals => false)
   end
 
   it "traps system signals and shuts down" do
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-
     expect(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('darwin12.0.0')
 
+    expect(config).to receive(:all).and_return({})
+
+    thread = double(Thread)
+    expect(thread).to receive(:join).exactly(3).times
+    expect(Thread).to receive(:new).exactly(3).times.and_yield.and_return(thread)
+
     expect(Kernel).to receive(:trap).with('INT').and_yield
     expect(Kernel).to receive(:trap).with('TERM').and_yield
     expect(Kernel).to receive(:trap).with('HUP').and_yield
 
-    expect(config).to receive(:all).and_return({})
-    expect(config).to receive(:for_redis).and_return({})
+    shutdown = double('shutdown')
+    expect(shutdown).to receive(:call).with(2).once
+    expect(shutdown).to receive(:call).with(15).once
+    reload = double('reload')
+    expect(reload).to receive(:call).once
+
     fc = Flapjack::Coordinator.new(config)
+    fc.instance_variable_set('@shutdown', shutdown)
+    fc.instance_variable_set('@reload', reload)
 
     fc.send(:setup_signals)
-    expect(fc.instance_variable_get('@received_signals')).to eq(['INT', 'TERM', 'HUP'])
   end
 
   it "only traps two system signals on Windows" do
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-
     expect(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('mswin')
 
+    expect(config).to receive(:all).and_return({})
+
+    thread = double(Thread)
+    expect(thread).to receive(:join).twice
+    expect(Thread).to receive(:new).twice.and_yield.and_return(thread)
+
     expect(Kernel).to receive(:trap).with('INT').and_yield
     expect(Kernel).to receive(:trap).with('TERM').and_yield
     expect(Kernel).not_to receive(:trap).with('HUP')
 
-    expect(config).to receive(:all).and_return({})
-    expect(config).to receive(:for_redis).and_return({})
+    shutdown = double('shutdown')
+    expect(shutdown).to receive(:call).with(2).once
+    expect(shutdown).to receive(:call).with(15).once
+    reload = double('reload')
+
     fc = Flapjack::Coordinator.new(config)
+    fc.instance_variable_set('@shutdown', shutdown)
+    fc.instance_variable_set('@reload', reload)
 
     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
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-
     old_cfg = {'processor' => {'enabled' => true}}
     new_cfg = {'gateways' => {'jabber' => {'enabled' => true}}}
 
-    new_config = double('new_config')
-    filename = double('filename')
-
-    expect(config).to receive(:all).twice.and_return(old_cfg)
-    expect(config).to receive(:filename).and_return(filename)
-
-    expect(Flapjack::Configuration).to receive(:new).and_return(new_config)
-    expect(new_config).to receive(:load).with(filename)
-    expect(new_config).to receive(:all).and_return(new_cfg)
+    expect(config).to receive(:all).exactly(3).times.and_return(old_cfg, old_cfg, new_cfg)
+    expect(config).to receive(:reload)
 
     processor = double('processor')
-    expect(processor).to receive(:type).twice.and_return('processor')
+    expect(processor).to receive(:type).and_return('processor')
     expect(processor).to receive(:stop)
-    expect(processor).to receive(:update_status)
-    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
-
-    expect(config).to receive(:for_redis).and_return({})
-    fc = Flapjack::Coordinator.new(config)
 
     jabber = double('jabber')
     expect(Flapjack::Pikelet).to receive(:create).
-      with('jabber', :config => {"enabled" => true}, :redis_config => {},
+      with('jabber', an_instance_of(Proc),
+        :config => {"enabled" => true},
         :boot_time => time).
-      and_return(jabber)
+      and_return([jabber])
     expect(jabber).to receive(:start)
 
+    fc = Flapjack::Coordinator.new(config)
+
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
     fc.send(:reload)
@@ -237,20 +204,11 @@ describe Flapjack::Coordinator do
   end
 
   it "reloads a pikelet config without restarting it" do
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-
     old_cfg = {'processor' => {'enabled' => true, 'foo' => 'bar'}}
     new_cfg = {'processor' => {'enabled' => true, 'foo' => 'baz'}}
 
-    new_config = double('new_config')
-    filename = double('filename')
-
-    expect(config).to receive(:all).twice.and_return(old_cfg)
-    expect(config).to receive(:filename).and_return(filename)
-
-    expect(Flapjack::Configuration).to receive(:new).and_return(new_config)
-    expect(new_config).to receive(:load).with(filename)
-    expect(new_config).to receive(:all).and_return(new_cfg)
+    expect(config).to receive(:all).exactly(3).times.and_return(old_cfg, old_cfg, new_cfg)
+    expect(config).to receive(:reload)
 
     processor = double('processor')
     expect(processor).not_to receive(:start)
@@ -258,7 +216,6 @@ describe Flapjack::Coordinator do
     expect(processor).to receive(:reload).with(new_cfg['processor']).and_return(true)
     expect(processor).not_to receive(:stop)
 
-    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
@@ -267,43 +224,32 @@ describe Flapjack::Coordinator do
   end
 
   it "reloads a pikelet config while restarting it" do
-    expect(Flapjack::Logger).to receive(:new).and_return(logger)
-
     old_cfg = {'processor' => {'enabled' => true, 'foo' => 'bar'}}
     new_cfg = {'processor' => {'enabled' => true, 'baz' => 'qux'}}
 
-    new_config = double('new_config')
-    filename = double('filename')
-
-    expect(config).to receive(:all).twice.and_return(old_cfg)
-    expect(config).to receive(:filename).and_return(filename)
-
-    expect(Flapjack::Configuration).to receive(:new).and_return(new_config)
-    expect(new_config).to receive(:load).with(filename)
-    expect(new_config).to receive(:all).and_return(new_cfg)
+    expect(config).to receive(:all).exactly(3).times.and_return(old_cfg, old_cfg, new_cfg)
+    expect(config).to receive(:reload)
 
     processor = double('processor')
     expect(processor).to receive(:type).exactly(5).times.and_return('processor')
     expect(processor).to receive(:reload).with(new_cfg['processor']).and_return(false)
     expect(processor).to receive(:stop)
-    expect(processor).to receive(:update_status)
-    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    new_exec = double('new_executive')
-    expect(new_exec).to receive(:start)
+    new_processor = double('new_processor')
+    expect(new_processor).to receive(:start)
 
-    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
 
     expect(Flapjack::Pikelet).to receive(:create).
-      with('processor', :config => new_cfg['processor'], :redis_config => {},
+      with('processor', an_instance_of(Proc),
+        :config => new_cfg['processor'],
         :boot_time => time).
-      and_return(new_exec)
+      and_return([new_processor])
 
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
     fc.send(:reload)
-    expect(fc.instance_variable_get('@pikelets')).to eq([new_exec])
+    expect(fc.instance_variable_get('@pikelets')).to eq([new_processor])
   end
 
 end