flapjack 0.6.39 → 0.6.40

data/lib/flapjack/patches.rb

@@ -88,6 +88,7 @@ module Resque
       startup
 
       loop do
+
         break if shutdown?
 
         if not paused? and job = reserve
@@ -118,8 +119,9 @@ module Resque
         end
       end
 
-    ensure
       unregister_worker
+    rescue Exception => exception
+      unregister_worker(exception)
     end
 
   end

data/lib/flapjack/pikelet.rb

@@ -12,11 +12,36 @@ require 'log4r'
 require 'log4r/outputter/consoleoutputters'
 require 'log4r/outputter/syslogoutputter'
 
-require 'flapjack/redis_pool'
-
 module Flapjack
   module Pikelet
-    attr_accessor :logger, :redis, :config
+    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
+
+      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
+
+      @config = opts[:config] || {}
+
+      @bootstrapped = true
+    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
+    end
+
+  end
+
+  module GenericPikelet
+    include Flapjack::Pikelet
 
     def should_quit?
       @should_quit
@@ -26,30 +51,36 @@ module Flapjack
       @should_quit = true
     end
 
-    def build_redis_connection_pool(options = {})
-      return unless @bootstrapped
-      if defined?(EventMachine) && defined?(EventMachine::Synchrony)
-        Flapjack::RedisPool.new(:config => @redis_config, :size => options[:size])
-      else
-        ::Redis.new(@redis_config)
-      end
+    alias_method :orig_bootstrap, :bootstrap
+
+    def bootstrap(opts = {})
+      @should_quit = false
+
+      orig_bootstrap(opts)
     end
 
+  end
+
+  module ResquePikelet
+    include Flapjack::Pikelet
+  end
+
+  module ThinPikelet
+    include Flapjack::Pikelet
+
+    attr_accessor :port
+
+    alias_method :orig_bootstrap, :bootstrap
+
     def bootstrap(opts = {})
       return if @bootstrapped
 
-      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"))
+      if config = opts[:config]
+        @port = config['port'] ? config['port'].to_i : nil
+        @port = 3001 if (@port.nil? || @port <= 0 || @port > 65535)
       end
 
-      @redis_config = opts[:redis] || {}
-      @config = opts[:config] || {}
-
-      @should_quit = false
-
-      @bootstrapped = true
+      orig_bootstrap(opts)
     end
 
   end

data/lib/flapjack/rack_logger.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+module Flapjack
+  class RackLogger < ::Logger
+    # Works around a 1.8-specific call to a Logger method in Rack::CommonLogger
+    def write(msg); self.send(:"<<", msg); end
+  end
+end

data/lib/flapjack/version.rb

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

data/lib/flapjack/web.rb

@@ -1,22 +1,24 @@
 #!/usr/bin/env ruby
 
-require 'fiber'
-
 require 'chronic'
 require 'chronic_duration'
 require 'sinatra/base'
 require 'haml'
 require 'rack/fiber_pool'
 
+require 'async-rack'
+require 'flapjack/rack_logger'
+
 require 'flapjack/pikelet'
 require 'flapjack/data/contact'
 require 'flapjack/data/entity_check'
+require 'flapjack/redis_pool'
 require 'flapjack/utility'
 
 module Flapjack
   class Web < Sinatra::Base
 
-    if 'test'.eql?(FLAPJACK_ENV)
+    if defined?(FLAPJACK_ENV) && 'test'.eql?(FLAPJACK_ENV)
       # expose test errors properly
       set :raise_errors, true
       set :show_exceptions, false
@@ -39,21 +41,47 @@ module Flapjack
       use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
     end
     use Rack::MethodOverride
-    extend Flapjack::Pikelet
+
+    web_logger = Flapjack::RackLogger.new('log/web_access.log')
+    use Rack::CommonLogger, web_logger
+
+    class << self
+      include Flapjack::ThinPikelet
+
+      attr_accessor :redis
+
+      alias_method :thin_bootstrap, :bootstrap
+      alias_method :thin_cleanup,   :cleanup
+
+      def bootstrap(opts = {})
+        thin_bootstrap(opts)
+        @redis = Flapjack::RedisPool.new(:config => opts[:redis_config], :size => 1)
+      end
+
+      def cleanup
+        @redis.empty! if @redis
+        thin_cleanup
+      end
+
+    end
+
     include Flapjack::Utility
 
     set :views, settings.root + '/web/views'
 
-    before do
-      # will only initialise the first time it's run
-      Flapjack::Web.bootstrap
+    def redis
+      self.class.instance_variable_get('@redis')
+    end
+
+    def logger
+      self.class.instance_variable_get('@logger')
     end
 
     get '/' do
       self_stats
 
       # TODO (?) recast as Entity.all do |e|; e.checks.do |ec|; ...
-      @states = @@redis.keys('*:*:states').map { |r|
+      @states = redis.keys('*:*:states').map { |r|
         parts  = r.split(':')[0..1]
         [parts[0], parts[1]] + entity_check_state(parts[0], parts[1])
       }.compact.sort_by {|parts| parts }
@@ -62,7 +90,7 @@ module Flapjack
 
     get '/failing' do
       self_stats
-      @states = @@redis.zrange('failed_checks', 0, -1).map {|key|
+      @states = redis.zrange('failed_checks', 0, -1).map {|key|
         parts  = key.split(':')
         [parts[0], parts[1]] + entity_check_state(parts[0], parts[1])
       }.compact.sort_by {|parts| parts}
@@ -176,7 +204,7 @@ module Flapjack
     end
 
     get '/contacts' do
-      @contacts = Flapjack::Data::Contact.all(:redis => @@redis)
+      @contacts = Flapjack::Data::Contact.all(:redis => redis)
       haml :contacts
     end
 
@@ -184,7 +212,7 @@ module Flapjack
       contact_id = params[:contact]
 
       if contact_id
-        @contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => @@redis)
+        @contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis)
       end
 
       unless @contact
@@ -207,17 +235,17 @@ module Flapjack
 
     def get_entity_check(entity, check)
       entity_obj = (entity && entity.length > 0) ?
-        Flapjack::Data::Entity.find_by_name(entity, :redis => @@redis) : nil
+        Flapjack::Data::Entity.find_by_name(entity, :redis => redis) : nil
       return if entity_obj.nil? || (check.nil? || check.length == 0)
-      Flapjack::Data::EntityCheck.for_entity(entity_obj, check, :redis => @@redis)
+      Flapjack::Data::EntityCheck.for_entity(entity_obj, check, :redis => redis)
     end
 
     def entity_check_state(entity_name, check)
       entity = Flapjack::Data::Entity.find_by_name(entity_name,
-        :redis => @@redis)
+        :redis => redis)
       return if entity.nil?
       entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
-        check, :redis => @@redis)
+        check, :redis => redis)
       latest_notif =
         {:problem         => entity_check.last_problem_notification,
          :recovery        => entity_check.last_recovery_notification,
@@ -238,22 +266,18 @@ module Flapjack
       @pid          = Process.pid
       @instance_id  = "#{@fqdn}:#{@pid}"
 
-      @keys = @@redis.keys '*'
-      @count_failing_checks    = @@redis.zcard 'failed_checks'
-      @count_all_checks        = @@redis.keys('check:*:*').length
-      @executive_instances     = @@redis.zrange('executive_instances', '0', '-1', :withscores => true)
-      @event_counters          = @@redis.hgetall('event_counters')
-      @event_counters_instance = @@redis.hgetall("event_counters:#{@instance_id}")
-      @boot_time               = Time.at(@@redis.zscore('executive_instances', @instance_id).to_i)
+      @keys = redis.keys '*'
+      @count_failing_checks    = redis.zcard 'failed_checks'
+      @count_all_checks        = redis.keys('check:*:*').length
+      @executive_instances     = redis.zrange('executive_instances', '0', '-1', :withscores => true)
+      @event_counters          = redis.hgetall('event_counters')
+      @event_counters_instance = redis.hgetall("event_counters:#{@instance_id}")
+      @boot_time               = Time.at(redis.zscore('executive_instances', @instance_id).to_i)
       @uptime                  = Time.now.to_i - @boot_time.to_i
       @uptime_string           = time_period_in_words(@uptime)
       @event_rate_all          = (@uptime > 0) ?
                                  (@event_counters_instance['all'].to_f / @uptime) : 0
-      @events_queued = @@redis.llen('events')
-    end
-
-    def logger
-      Flapjack::Web.logger
+      @events_queued = redis.llen('events')
     end
 
   end

data/spec/lib/flapjack/api_spec.rb

@@ -10,7 +10,7 @@ describe 'Flapjack::API', :sinatra => true do
   let(:entity)          { mock(Flapjack::Data::Entity) }
   let(:entity_check)    { mock(Flapjack::Data::EntityCheck) }
 
-  let(:entity_name)     { 'example.com'}
+  let(:entity_name)     { 'www.example.net'}
   let(:entity_name_esc) { URI.escape(entity_name) }
   let(:check)           { 'ping' }
 
@@ -20,7 +20,8 @@ describe 'Flapjack::API', :sinatra => true do
   let(:redis)           { mock(::Redis) }
 
   before(:each) do
-    Flapjack::API.class_variable_set('@@redis', redis)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    Flapjack::API.bootstrap(:config => {})
   end
 
   it "returns a list of checks for an entity" do
@@ -49,6 +50,17 @@ describe 'Flapjack::API', :sinatra => true do
     last_response.body.should == result_json
   end
 
+  it "creates an acknowledgement for an entity check" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+    entity_check.should_receive(:create_acknowledgement).with('summary' => nil, 'duration' => (4 * 60 * 60))
+
+    post "/acknowledgements/#{entity_name_esc}/#{check}"
+    last_response.status.should == 204
+  end
+
   it "returns a list of scheduled maintenance periods within a time window for an entity"
 
   it "returns a list of scheduled maintenance periods for a check on an entity" do
@@ -167,6 +179,19 @@ describe 'Flapjack::API', :sinatra => true do
     last_response.body.should == result_json
   end
 
+  it "creates a test notification event for check on an entity" do
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    entity.should_receive(:name).and_return(entity_name)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'foo', :redis => redis).and_return(entity_check)
+    entity_check.should_receive(:test_notifications)
+
+    post "/test_notifications/#{entity_name_esc}/foo"
+    last_response.status.should == 204
+  end
+
   it "creates entities from a submitted list" do
     entities = {'entities' =>
       [
@@ -266,4 +291,4 @@ describe 'Flapjack::API', :sinatra => true do
     last_response.status.should == 200
   end
 
-end
+end

data/spec/lib/flapjack/coordinator_spec.rb

@@ -13,57 +13,80 @@ describe Flapjack::Coordinator do
     }
   }
 
-  before(:each) {
-    # temporary workaround for failing test due to preserved state;
-    # won't be needed soon as this code has been fixed in a branch
-    Flapjack::API.class_variable_set('@@redis', nil)
-    Flapjack::Web.class_variable_set('@@redis', nil)
-  }
+  let(:redis_config) { {} }
 
   # leaving actual testing of daemonisation to that class's tests
   it "daemonizes properly" do
-    fc = Flapjack::Coordinator.new(config)
+    fc = Flapjack::Coordinator.new(config, redis_config)
     fc.should_receive(:daemonize)
     fc.should_not_receive(:build_pikelet)
-    fc.should_not_receive(:build_resque_pikelet)
-    fc.should_not_receive(:build_thin_pikelet)
     fc.start(:daemonize => true, :signals => false)
   end
 
   it "runs undaemonized" do
     EM.should_receive(:synchrony).and_yield
 
-    fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:build_pikelet)
-    fc.should_receive(:build_resque_pikelet)
-    fc.should_receive(:build_thin_pikelet)
+    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc.should_receive(:build_pikelet).exactly(3).times
     fc.start(:daemonize => false, :signals => false)
   end
 
   it "starts after daemonizing" do
     EM.should_receive(:synchrony).and_yield
 
-    fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:build_pikelet)
-    fc.should_receive(:build_resque_pikelet)
-    fc.should_receive(:build_thin_pikelet)
+    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc.should_receive(:build_pikelet).exactly(3).times
     fc.after_daemonize
   end
 
-  it "traps system signals and shuts down"
+  it "traps system signals and shuts down" do
+    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
+
+    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc.should_receive(:stop).exactly(3).times
+
+    fc.send(:setup_signals)
+  end
+
+  it "only traps two system signals on Windows" do
+    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')
+
+    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc.should_receive(:stop).twice
+
+    fc.send(:setup_signals)
+  end
 
-  # TODO whem merged with other changes, this will check pik[:class] instead,
-  # having to create instances of the pikelet classes is messy
   it "stops its services when closing" do
     fiber_exec = mock('fiber_exec')
     fiber_rsq  = mock('fiber_rsq')
 
-    exec  = Flapjack::Executive.new
+    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)
-    email = EM::Resque::Worker.new('example')
+    exec.should_receive(:cleanup)
+
+    email = mock('worker')
+    email.should_receive(:is_a?).with(Flapjack::GenericPikelet).twice.and_return(false)
     email.should_receive(:shutdown)
-    web   = Thin::Server.new('0.0.0.0', 3000, Flapjack::Web, :signals => false)
+    Flapjack::Notification::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::Web.should_receive(:cleanup)
 
     redis = mock('redis')
     redis.should_receive(:quit)
@@ -74,16 +97,17 @@ describe Flapjack::Coordinator do
     fiber_stop.should_receive(:resume)
     Fiber.should_receive(:new).twice.and_yield.and_return(fiber, fiber_stop)
 
-    fiber_exec.should_receive(:alive?).and_return(true, false)
-    fiber_rsq.should_receive(:alive?).and_return(true, false)
+    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)
 
+    EM::Synchrony.should_receive(:sleep)
     EM.should_receive(:stop)
 
-    pikelets = [{:fiber => fiber_exec, :instance => exec},
-                {:fiber => fiber_rsq,  :instance => email},
-                {:instance => web}]
+    pikelets = [{:fiber => fiber_exec, :instance => exec, :class => Flapjack::Executive},
+                {:fiber => fiber_rsq,  :instance => email, :class => Flapjack::Notification::Email},
+                {:instance => web, :class => Flapjack::Web}]
 
-    fc = Flapjack::Coordinator.new
+    fc = Flapjack::Coordinator.new(config, redis_config)
     fc.instance_variable_set('@redis_options', {})
     fc.instance_variable_set('@pikelets', pikelets)
     fc.stop
@@ -93,37 +117,39 @@ describe Flapjack::Coordinator 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)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    fc = Flapjack::Coordinator.new
+    fc = Flapjack::Coordinator.new(config, redis_config)
     fc.send(:build_pikelet, 'executive', {})
     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, :type => 'executive', :instance => exec}
+    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Executive, :instance => exec}
   end
 
-  it "handles an exception raised by a jabber pikelet" do
+  it "handles an exception raised by a fiber pikelet" do
     jabber = mock('jabber')
     jabber.should_receive(:bootstrap)
     Flapjack::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)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    fc = Flapjack::Coordinator.new
+    fc = Flapjack::Coordinator.new(config, redis_config)
     fc.should_receive(:stop)
     fc.send(:build_pikelet, 'jabber_gateway', {})
     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, :type => 'jabber_gateway', :instance => jabber}
+    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Jabber, :instance => jabber}
   end
 
   it "creates a resque worker pikelet" do
@@ -138,20 +164,18 @@ describe Flapjack::Coordinator do
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    fc = Flapjack::Coordinator.new
-    fc.send(:build_resque_pikelet, 'email_notifier', {})
+    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc.send(:build_pikelet, 'email_notifier', {})
     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, :type => 'email_notifier', :instance => worker}
+    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Notification::Email,
+                              :instance => worker}
   end
 
-  it "handles an exception raised by a resque worker pikelet"
-
   it "creates a thin server pikelet" do
     redis = mock('redis')
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
 
     server = mock('server')
     server.should_receive(:start)
@@ -159,13 +183,15 @@ describe Flapjack::Coordinator do
       with(/^(?:\d{1,3}\.){3}\d{1,3}$/, an_instance_of(Fixnum), Flapjack::Web, :signals => false).
       and_return(server)
 
-    fc = Flapjack::Coordinator.new
-    fc.send(:build_thin_pikelet, 'web', {})
+    Flapjack::RedisPool.should_receive(:new)
+
+    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc.send(:build_pikelet, 'web', {})
     pikelets = fc.instance_variable_get('@pikelets')
     pikelets.should_not be_nil
     pikelets.should be_an(Array)
     pikelets.should have(1).pikelet
-    pikelets.first.should == {:type => 'web', :instance => server}
+    pikelets.first.should == {:class => Flapjack::Web, :instance => server}
   end
 
   # NB: exceptions are handled directly by the Thin pikelets