flapjack 0.6.53 → 0.6.54

data/lib/flapjack/logger.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'log4r'
+require 'log4r/formatter/patternformatter'
+require 'log4r/outputter/consoleoutputters'
+require 'log4r/outputter/syslogoutputter'
+
+module Flapjack
+
+  class Logger
+
+    def initialize(name, config = {})
+      config ||= {}
+
+      # @name = name
+
+      @log4r_logger = Log4r::Logger.new(name)
+
+      formatter = Log4r::PatternFormatter.new(:pattern => "%d [%l] :: #{name} :: %m",
+        :date_pattern => "%Y-%m-%dT%H:%M:%S%z")
+
+      [Log4r::StdoutOutputter, Log4r::SyslogOutputter].each do |outp_klass|
+        outp = outp_klass.new(name)
+        outp.formatter = formatter
+        @log4r_logger.add(outp)
+      end
+
+      configure(config)
+    end
+
+    def configure(config)
+      level = config['level']
+
+      # we'll let Log4r spit the dummy on invalid level values -- but will
+      # assume ALL if nothing is provided
+      if level.nil? || level.empty?
+        level = 'ALL'
+      end
+
+      new_level = Log4r.const_get(level.upcase)
+      return if @log4r_logger.level.eql?(new_level)
+
+      # puts "setting log level for '#{@name}' to '#{level.upcase}'"
+      @log4r_logger.level = new_level
+    end
+
+    def method_missing(method, *args, &block)
+      @log4r_logger.send(method.to_sym, *args, &block)
+    end
+
+    def respond_to?(sym)
+      @log4r_logger.respond_to?(sym)
+    end
+
+  end
+
+end

data/lib/flapjack/patches.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
 require 'ostruct'
-require 'daemons'
 require 'thin'
 require 'resque'
 # require 'log4r'
@@ -12,15 +11,6 @@ class OpenStruct
   end
 end
 
-module Daemons
-  class PidFile
-    # we override this method so creating pid files is fork-safe
-    def filename
-      File.join(@dir, "#{@progname}#{Process.pid}.pid")
-    end
-  end
-end
-
 #module Log4r
 #  class Logger
 #    def error(args)

data/lib/flapjack/pikelet.rb

@@ -8,55 +8,239 @@
 # with butter, at afternoon tea, but can also be served at morning tea."
 #    from http://en.wikipedia.org/wiki/Pancake
 
-require 'log4r'
-require 'log4r/outputter/consoleoutputters'
-require 'log4r/outputter/syslogoutputter'
+# the redis/synchrony gems need to be required in this particular order, see
+# the redis-rb README for details
+require 'hiredis'
+require 'redis/connection/synchrony'
+require 'redis'
+require 'em-resque'
+require 'em-resque/worker'
+require 'thin'
+
+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'
+require 'flapjack/logger'
 
 module Flapjack
+
   module Pikelet
-    attr_accessor :logger, :config
 
-    # Classes including a pikelet subclass and wanting to extend #bootstrap
-    # should alias the original method and make sure to call them
-    # as part of their interstitial method.
-    def bootstrap(opts = {})
-      return if @bootstrapped
+    # TODO find a better way of expressing these two methods
+    def self.is_pikelet?(type)
+      type_klass = [Flapjack::Pikelet::Generic, Flapjack::Pikelet::Resque,
+        Flapjack::Pikelet::Thin].detect do |kl|
 
-      unless @logger = opts[:logger]
-        @logger = Log4r::Logger.new("#{self.class.to_s.downcase.gsub('::', '-')}")
-        @logger.add(Log4r::StdoutOutputter.new("flapjack"))
-        @logger.add(Log4r::SyslogOutputter.new("flapjack"))
-      end
+        kl::PIKELET_TYPES[type]
 
-      @config = opts[:config] || {}
+      end
+      !type_klass.nil?
+    end
 
-      @bootstrapped = true
+    def self.create(type, config = {})
+      pikelet = nil
+      [Flapjack::Pikelet::Generic,
+       Flapjack::Pikelet::Resque,
+       Flapjack::Pikelet::Thin].each do |kl|
+        break if pikelet = kl.create(type, config)
+      end
+      pikelet
     end
 
-    # Aliasing isn't currently necessary for #cleanup, as it's empty anyway.
-    # It's probably best practice to do so, in case that changes.
-    def cleanup
+    class Base
+      attr_reader :type, :status
+
+      def initialize(type, pikelet_class, opts = {})
+        @type = type
+        @klass = pikelet_class
+
+        @config = opts[:config] || {}
+        @redis_config = opts[:redis_config] || {}
+
+        @logger = Flapjack::Logger.new("flapjack-#{type}", @config['logger'])
+
+        @status = 'initialized'
+      end
+
+      def start
+        @status = 'started'
+      end
+
+      def reload(cfg)
+        @logger.configure(cfg['logger'])
+        true
+      end
+
+      def stop
+        @status = 'stopping'
+      end
     end
 
-  end
+    class Generic < Flapjack::Pikelet::Base
+
+     PIKELET_TYPES = {'executive'  => Flapjack::Executive,
+                      'jabber'     => Flapjack::Gateways::Jabber,
+                      'pagerduty'  => Flapjack::Gateways::Pagerduty,
+                      'oobetet'    => Flapjack::Gateways::Oobetet}
+
+      def self.create(type, config = {})
+        return unless pikelet_klass = PIKELET_TYPES[type]
+        self.new(type, pikelet_klass, config)
+      end
+
+      def initialize(type, pikelet_klass, opts = {})
+        super(type, pikelet_klass, opts)
+        @pikelet = @klass.new(opts.merge(:logger => @logger))
+      end
 
-  module GenericPikelet
-    include Flapjack::Pikelet
+      def start
+        @fiber = Fiber.new {
+          begin
+            @pikelet.start
+          rescue Exception => e
+            trace = e.backtrace.join("\n")
+            @logger.fatal "#{e.message}\n#{trace}"
+            stop
+          end
+        }
+        super
+        @fiber.resume
+      end
+
+      # this should only reload if all changes can be applied -- will
+      # return false to log warning otherwise
+      def reload(cfg)
+        @pikelet.respond_to?(:reload) ?
+          (@pikelet.reload(cfg) && super(cfg)) : super(cfg)
+      end
 
-    def should_quit?
-      @should_quit
+      def stop
+        @pikelet.stop
+        super
+      end
+
+      def update_status
+        return @status unless 'stopping'.eql?(@status)
+        @status = 'stopped' if @fiber && !@fiber.alive?
+      end
     end
 
-    def stop
-      @should_quit = true
+    class Resque < Flapjack::Pikelet::Base
+
+      PIKELET_TYPES = {'email' => Flapjack::Gateways::Email,
+                       'sms'   => Flapjack::Gateways::SmsMessagenet}
+
+      def self.create(type, opts = {})
+        return unless pikelet_klass = PIKELET_TYPES[type]
+        self.new(type, pikelet_klass, opts)
+      end
+
+      def initialize(type, pikelet_klass, opts = {})
+        super(type, pikelet_klass, opts)
+
+        pikelet_klass.instance_variable_set('@config', @config)
+        pikelet_klass.instance_variable_set('@redis_config', @redis_config)
+        pikelet_klass.instance_variable_set('@logger', @logger)
+
+        # TODO error if config['queue'].nil?
+
+        @worker = EM::Resque::Worker.new(@config['queue'])
+        # # Use these to debug the resque workers
+        # worker.verbose = true
+        # worker.very_verbose = true
+      end
+
+      def start
+        @fiber = Fiber.new {
+          begin
+            @worker.work(0.1)
+          rescue Exception => e
+            trace = e.backtrace.join("\n")
+            @logger.fatal "#{e.message}\n#{trace}"
+            stop
+          end
+        }
+        super
+        @klass.start if @klass.respond_to?(:start)
+        @fiber.resume
+      end
+
+      # this should only reload if all changes can be applied -- will
+      # return false to log warning otherwise
+      def reload(cfg)
+        @klass.respond_to?(:reload) ?
+          (@klass.reload(cfg) && super(cfg)) : super(cfg)
+      end
+
+      def stop
+        @worker.shutdown if @worker && @fiber && @fiber.alive?
+        @klass.stop if @klass.respond_to?(:stop)
+        super
+      end
+
+      def update_status
+        return @status unless 'stopping'.eql?(@status)
+        @status = 'stopped' if @fiber && !@fiber.alive?
+      end
     end
 
-    alias_method :orig_bootstrap, :bootstrap
+    class Thin < Flapjack::Pikelet::Base
 
-    def bootstrap(opts = {})
-      @should_quit = false
+      PIKELET_TYPES = {'web'  => Flapjack::Gateways::Web,
+                       'api'  => Flapjack::Gateways::API}
 
-      orig_bootstrap(opts)
+      def self.create(type, opts = {})
+        return unless pikelet_klass = PIKELET_TYPES[type]
+        ::Thin::Logging.silent = true
+        self.new(type, pikelet_klass, :config => opts[:config], :redis_config => opts[:redis_config])
+      end
+
+      def initialize(type, pikelet_klass, opts = {})
+        super(type, pikelet_klass, opts)
+
+        pikelet_klass.instance_variable_set('@config', @config)
+        pikelet_klass.instance_variable_set('@redis_config', @redis_config)
+        pikelet_klass.instance_variable_set('@logger', @logger)
+
+        if @config
+          @port = @config['port']
+          @port = @port.nil? ? nil : @port.to_i
+        end
+        @port = 3001 if (@port.nil? || @port <= 0 || @port > 65535)
+
+        @server = ::Thin::Server.new('0.0.0.0', @port,
+                    @klass, :signals => false)
+      end
+
+      def start
+        super
+        @klass.start if @klass.respond_to?(:start)
+        @server.start
+      end
+
+      # this should only reload if all changes can be applied -- will
+      # return false to log warning otherwise
+      def reload(cfg)
+        # TODO fail if port changes
+        @klass.respond_to?(:reload) ?
+          (@klass.reload(cfg) && super(cfg)) : super(cfg)
+      end
+
+      def stop
+        @server.stop!
+        @klass.stop if @klass.respond_to?(:stop)
+        super
+      end
+
+      def update_status
+        return @status unless 'stopping'.eql?(@status)
+        @status = 'stopped' if (@server.backend.size <= 0)
+      end
     end
 
   end

data/lib/flapjack/redis_pool.rb

@@ -15,26 +15,11 @@ module Flapjack
 
     def initialize(opts = {})
       config = opts.delete(:config)
-      super(:size => opts[:size] || 5) {
+      @size = opts[:size] || 5
+      super(:size => @size) {
         ::Redis.new(config)
       }
     end
 
-    def empty!
-      f = Fiber.current
-
-      until @available.empty? && @pending.empty?
-        begin
-          conn = acquire(f)
-          conn.quit
-          @available.delete(conn)
-        ensure
-          if pending = @pending.shift
-            pending.resume
-          end
-        end
-      end
-    end
-
   end
 end

data/lib/flapjack/version.rb

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

data/spec/lib/flapjack/coordinator_spec.rb

@@ -1,12 +1,5 @@
 require 'spec_helper'
 
-require 'flapjack/configuration'
-require 'flapjack/executive'
-
-require 'flapjack/gateways/web'
-require 'flapjack/gateways/jabber'
-require 'flapjack/gateways/email'
-
 require 'flapjack/coordinator'
 
 describe Flapjack::Coordinator do
@@ -14,57 +7,80 @@ describe Flapjack::Coordinator do
   let(:fiber)  { mock(Fiber) }
   let(:config) { mock(Flapjack::Configuration) }
 
-  # leaving actual testing of daemonisation to that class's tests
-  it "daemonizes properly" do
-    config.should_receive(:for_redis).and_return({})
-    fc = Flapjack::Coordinator.new(config)
+  let(:logger)     { mock(Logger) }
+  let(:stdout_out) { mock('stdout_out') }
+  let(:syslog_out) { mock('syslog_out') }
+
+  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)
+
+    stdout_out.should_receive(:formatter=).with(formatter)
+    syslog_out.should_receive(:formatter=).with(formatter)
 
-    fc.should_receive(:daemonize)
-    fc.should_not_receive(:build_pikelet)
-    fc.start(:daemonize => true, :signals => false)
+    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)
   end
 
-  it "runs undaemonized" do
+  it "starts and stops a pikelet" do
+    setup_logger
+
+    cfg = {'executive' => {'enabled' => 'yes'}}
     EM.should_receive(:synchrony).and_yield
     config.should_receive(:for_redis).and_return({})
-    config.should_receive(:all).and_return('executive' => {'enabled' => 'yes'})
+    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')
 
     fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:build_pikelet)
-    fc.start(:daemonize => false, :signals => false)
-  end
+    Flapjack::Pikelet.should_receive(:create).with('executive',
+        :config => cfg['executive'], :redis_config => {}).and_return(executive)
 
-  it "starts after daemonizing" do
-    EM.should_receive(:synchrony).and_yield
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    config.should_receive(:for_redis).and_return({})
-    config.should_receive(:all).and_return('executive' => {'enabled' => 'yes'})
+    EM.should_receive(:stop)
 
-    fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:build_pikelet)
-    fc.after_daemonize
+    fc.start(:signals => false)
+    fc.stop
   end
 
   it "traps system signals and shuts down" do
+    setup_logger
+
     RbConfig::CONFIG.should_receive(:[]).with('host_os').and_return('darwin12.0.0')
 
     Kernel.should_receive(:trap).with('INT').and_yield
     Kernel.should_receive(:trap).with('TERM').and_yield
     Kernel.should_receive(:trap).with('QUIT').and_yield
+    Kernel.should_receive(:trap).with('HUP').and_yield
 
     config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
     fc.should_receive(:stop).exactly(3).times
+    fc.should_receive(:reload)
 
     fc.send(:setup_signals)
   end
 
   it "only traps two system signals on Windows" do
+    setup_logger
+
     RbConfig::CONFIG.should_receive(:[]).with('host_os').and_return('mswin')
 
     Kernel.should_receive(:trap).with('INT').and_yield
     Kernel.should_receive(:trap).with('TERM').and_yield
     Kernel.should_not_receive(:trap).with('QUIT')
+    Kernel.should_not_receive(:trap).with('HUP')
 
     config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
@@ -73,145 +89,109 @@ describe Flapjack::Coordinator do
     fc.send(:setup_signals)
   end
 
-  it "stops its services when closing" do
-    fiber_exec = mock('fiber_exec')
-    fiber_rsq  = mock('fiber_rsq')
-
-    exec  = mock('executive')
-    exec.should_receive(:is_a?).with(Flapjack::GenericPikelet).twice.and_return(true)
-    exec.should_receive(:stop)
-    exec.should_receive(:add_shutdown_event)
-    exec.should_receive(:cleanup)
-
-    email = mock('worker')
-    email.should_receive(:is_a?).with(Flapjack::GenericPikelet).twice.and_return(false)
-    email.should_receive(:shutdown)
-    Flapjack::Gateways::Email.should_receive(:cleanup)
-
-    backend = mock('backend')
-    backend.should_receive(:size).twice.and_return(1, 0)
-    web = mock('web')
-    web.should_receive(:is_a?).with(Flapjack::GenericPikelet).twice.and_return(false)
-    web.should_receive(:backend).twice.and_return(backend)
-    web.should_receive(:stop!)
-    Flapjack::Gateways::Web.should_receive(:cleanup)
-
-    redis = mock('redis')
-    redis.should_receive(:quit)
-    Redis.should_receive(:new).and_return(redis)
+  it "stops one pikelet and starts another on reload" do
+    setup_logger
 
-    fiber.should_receive(:resume)
-    fiber_stop = mock('fiber_stop')
-    fiber_stop.should_receive(:resume)
-    Fiber.should_receive(:new).twice.and_yield.and_return(fiber, fiber_stop)
+    old_cfg = {'executive' => {'enabled' => 'yes'}}
+    new_cfg = {'gateways' => {'jabber' => {'enabled' => 'yes'}}}
 
-    fiber_exec.should_receive(:alive?).exactly(3).times.and_return(true, true, false)
-    fiber_rsq.should_receive(:alive?).exactly(3).and_return(true, false, false)
+    new_config = mock('new_config')
+    filename = mock('filename')
 
-    EM::Synchrony.should_receive(:sleep)
-    EM.should_receive(:stop)
+    config.should_receive(:all).and_return(old_cfg)
+    config.should_receive(:filename).and_return(filename)
 
-    pikelets = [{:fiber => fiber_exec, :instance => exec, :class => Flapjack::Executive},
-                {:fiber => fiber_rsq,  :instance => email, :class => Flapjack::Gateways::Email},
-                {:instance => web, :class => Flapjack::Gateways::Web}]
+    Flapjack::Configuration.should_receive(:new).and_return(new_config)
+    new_config.should_receive(:load).with(filename)
+    new_config.should_receive(:all).and_return(new_cfg)
 
-    config.should_receive(:for_redis).and_return({})
+    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')
 
-    fc = Flapjack::Coordinator.new(config)
-    fc.instance_variable_set('@redis_options', {})
-    fc.instance_variable_set('@pikelets', pikelets)
-    fc.stop
-  end
-
-  it "creates an executive pikelet" do
-    exec = mock('executive')
-    exec.should_receive(:bootstrap)
-    Flapjack::Executive.should_receive(:new).and_return(exec)
-    exec.should_receive(:is_a?).with(Flapjack::GenericPikelet).and_return(true)
-    exec.should_receive(:main)
+    jabber = mock('jabber')
+    Flapjack::Pikelet.should_receive(:create).with('jabber',
+      :config => {"enabled" => "yes"}, :redis_config => {}).and_return(jabber)
+    jabber.should_receive(:start)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
     config.should_receive(:for_redis).and_return({})
-
     fc = Flapjack::Coordinator.new(config)
-    fc.send(:build_pikelet, Flapjack::Executive, {'enabled' => 'yes'})
-    pikelets = fc.instance_variable_get('@pikelets')
-    pikelets.should_not be_nil
-    pikelets.should be_an(Array)
-    pikelets.should have(1).pikelet
-    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Executive, :instance => exec}
+    fc.instance_variable_set('@pikelets', [executive])
+    fc.reload
+    fc.instance_variable_get('@pikelets').should == [jabber]
   end
 
-  it "handles an exception raised by a fiber pikelet" do
-    jabber = mock('jabber')
-    jabber.should_receive(:bootstrap)
-    Flapjack::Gateways::Jabber.should_receive(:new).and_return(jabber)
-    jabber.should_receive(:is_a?).with(Flapjack::GenericPikelet).and_return(true)
-    jabber.should_receive(:main).and_raise(RuntimeError)
+  it "reloads a pikelet config without restarting it" do
+    setup_logger
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    old_cfg = {'executive' => {'enabled' => 'yes', 'foo' => 'bar'}}
+    new_cfg = {'executive' => {'enabled' => 'yes', 'foo' => 'baz'}}
 
-    config.should_receive(:for_redis).and_return({})
+    new_config = mock('new_config')
+    filename = mock('filename')
+
+    config.should_receive(:all).and_return(old_cfg)
+    config.should_receive(:filename).and_return(filename)
+
+    Flapjack::Configuration.should_receive(:new).and_return(new_config)
+    new_config.should_receive(:load).with(filename)
+    new_config.should_receive(:all).and_return(new_cfg)
+
+    executive = mock('executive')
+    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)
 
+    config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:stop)
-    fc.send(:build_pikelet, Flapjack::Gateways::Jabber, {'enabled' => 'yes'})
-    pikelets = fc.instance_variable_get('@pikelets')
-    pikelets.should_not be_nil
-    pikelets.should be_an(Array)
-    pikelets.should have(1).pikelet
-    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Gateways::Jabber, :instance => jabber}
+    fc.instance_variable_set('@pikelets', [executive])
+    fc.reload
+    fc.instance_variable_get('@pikelets').should == [executive]
   end
 
-  it "creates a resque worker pikelet" do
-    redis = mock('redis')
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
-    Resque.should_receive(:redis=).with(redis)
+  it "reloads a pikelet config while restarting it" do
+    setup_logger
 
-    worker = mock('worker')
-    EM::Resque::Worker.should_receive(:new).and_return(worker)
-    worker.should_receive(:work)
+    old_cfg = {'executive' => {'enabled' => 'yes', 'foo' => 'bar'}}
+    new_cfg = {'executive' => {'enabled' => 'yes', 'baz' => 'qux'}}
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    new_config = mock('new_config')
+    filename = mock('filename')
 
-    config.should_receive(:for_redis).and_return({})
+    config.should_receive(:all).and_return(old_cfg)
+    config.should_receive(:filename).and_return(filename)
 
-    fc = Flapjack::Coordinator.new(config)
-    fc.send(:build_pikelet, Flapjack::Gateways::Email, {'enabled' => 'yes'})
-    pikelets = fc.instance_variable_get('@pikelets')
-    pikelets.should_not be_nil
-    pikelets.should be_an(Array)
-    pikelets.should have(1).pikelet
-    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Gateways::Email,
-                              :instance => worker}
-  end
+    Flapjack::Configuration.should_receive(:new).and_return(new_config)
+    new_config.should_receive(:load).with(filename)
+    new_config.should_receive(:all).and_return(new_cfg)
 
-  it "creates a thin server pikelet" do
-    redis = mock('redis')
+    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')
 
-    server = mock('server')
-    server.should_receive(:start)
-    Thin::Server.should_receive(:new).
-      with(/^(?:\d{1,3}\.){3}\d{1,3}$/, an_instance_of(Fixnum), Flapjack::Gateways::Web, :signals => false).
-      and_return(server)
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    Flapjack::RedisPool.should_receive(:new)
+    new_exec = mock('new_executive')
+    new_exec.should_receive(:start)
 
-    config.should_receive(:for_redis).and_return({})
+    Flapjack::Pikelet.should_receive(:create).
+      with('executive', :config => new_cfg['executive'], :redis_config => {}).
+      and_return(new_exec)
 
+    config.should_receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
-    fc.send(:build_pikelet, Flapjack::Gateways::Web, {'enabled' => 'yes'})
-    pikelets = fc.instance_variable_get('@pikelets')
-    pikelets.should_not be_nil
-    pikelets.should be_an(Array)
-    pikelets.should have(1).pikelet
-    pikelets.first.should == {:class => Flapjack::Gateways::Web, :instance => server}
+    fc.instance_variable_set('@pikelets', [executive])
+    fc.reload
+    fc.instance_variable_get('@pikelets').should == [new_exec]
   end
 
-  # NB: exceptions are handled directly by the Thin pikelets
-
-end
+end