flapjack 0.6.43 → 0.6.44

data/lib/flapjack/{notification → gateways}/sms.rb

@@ -1,14 +1,13 @@
 #!/usr/bin/env ruby
 
 require 'flapjack/pikelet'
-require 'flapjack/notification/sms/messagenet'
+require 'flapjack/gateways/sms/messagenet'
 
 module Flapjack
-  module Notification
+  module Gateways
 
     class Sms
-
-      extend Flapjack::ResquePikelet
+      extend Flapjack::Gateways::Resque
 
       class << self
 
@@ -41,9 +40,9 @@ module Flapjack
           message += " at #{Time.at(time).strftime('%-d %b %H:%M')}, #{summary}"
 
           notification['message'] = message
-          Flapjack::Notification::Sms::Messagenet.sender(notification,
+          Flapjack::Gateways::Sms::Messagenet.sender(notification,
             :logger => opts[:logger],
-            :config => Flapjack::Notification::Sms.instance_variable_get('@config'))
+            :config => Flapjack::Gateways::Sms.instance_variable_get('@config'))
         end
 
       end

data/lib/flapjack/{notification → gateways}/sms/messagenet.rb

@@ -4,7 +4,7 @@ require 'net/http'
 require 'uri'
 
 module Flapjack
-  module Notification
+  module Gateways
     class Sms
       class Messagenet
 

data/lib/flapjack/gateways/web.rb

@@ -0,0 +1,293 @@
+#!/usr/bin/env ruby
+
+require 'chronic'
+require 'chronic_duration'
+require 'sinatra/base'
+require 'haml'
+require 'rack/fiber_pool'
+
+require 'async-rack'
+require 'flapjack/rack_logger'
+
+require 'flapjack/data/contact'
+require 'flapjack/data/entity_check'
+require 'flapjack/redis_pool'
+require 'flapjack/utility'
+
+require 'flapjack/gateways/base'
+
+module Flapjack
+
+  module Gateways
+
+    class Web < Sinatra::Base
+
+      if defined?(FLAPJACK_ENV) && 'test'.eql?(FLAPJACK_ENV)
+        # expose test errors properly
+        set :raise_errors, true
+        set :show_exceptions, false
+      else
+        rescue_exception = Proc.new do |env, e|
+          if settings.show_exceptions?
+            # ensure the sinatra error page shows properly
+            request = Sinatra::Request.new(env)
+            printer = Sinatra::ShowExceptions.new(proc{ raise e })
+            s, h, b = printer.call(env)
+            [s, h, b]
+          else
+            logger.error e.message
+            logger.error e.backtrace.join("\n")
+            [503, {}, ""]
+          end
+        end
+
+        # doesn't work with Rack::Test unless we wrap tests in EM.synchrony blocks
+        use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
+      end
+      use Rack::MethodOverride
+
+      class << self
+        include Flapjack::Gateways::Thin
+
+        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)
+
+          if config && config['access_log']
+            access_logger = Flapjack::RackLogger.new(config['access_log'])
+            use Rack::CommonLogger, access_logger
+          end
+        end
+
+        def cleanup
+          @redis.empty! if @redis
+          thin_cleanup
+        end
+
+      end
+
+      include Flapjack::Utility
+
+      set :views, settings.root + '/web/views'
+
+      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|
+          parts  = r.split(':')[0..1]
+          [parts[0], parts[1]] + entity_check_state(parts[0], parts[1])
+        }.compact.sort_by {|parts| parts }
+        haml :index
+      end
+
+      get '/failing' do
+        self_stats
+        @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}
+        haml :index
+      end
+
+      get '/self_stats' do
+        self_stats
+        haml :self_stats
+      end
+
+      get '/check' do
+        @entity = params[:entity]
+        @check  = params[:check]
+
+        entity_check = get_entity_check(@entity, @check)
+        return 404 if entity_check.nil?
+
+        last_change = entity_check.last_change
+
+        @check_state                = entity_check.state
+        @check_last_update          = entity_check.last_update
+        @check_last_change          = last_change
+        @check_summary              = entity_check.summary
+        @last_notifications         = entity_check.last_notifications_of_each_type
+        @scheduled_maintenances     = entity_check.maintenances(nil, nil, :scheduled => true)
+        @acknowledgement_id         = entity_check.failed? ?
+          entity_check.event_count_at(entity_check.last_change) : nil
+
+        @current_scheduled_maintenance   = entity_check.current_maintenance(:scheduled => true)
+        @current_unscheduled_maintenance = entity_check.current_maintenance(:scheduled => false)
+
+        @contacts                   = entity_check.contacts
+
+        haml :check
+      end
+
+      post '/acknowledgements/:entity/:check' do
+        @entity             = params[:entity]
+        @check              = params[:check]
+        @summary            = params[:summary]
+        @acknowledgement_id = params[:acknowledgement_id]
+
+        dur = ChronicDuration.parse(params[:duration] || '')
+        @duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
+
+        entity_check = get_entity_check(@entity, @check)
+        return 404 if entity_check.nil?
+
+        ack = entity_check.create_acknowledgement('summary' => (@summary || ''),
+          'acknowledgement_id' => @acknowledgement_id, 'duration' => @duration)
+
+        redirect back
+      end
+
+      # FIXME: there is bound to be a more idiomatic / restful way of doing this
+      # (probably using 'delete' or 'patch')
+      post '/end_unscheduled_maintenance/:entity/:check' do
+        @entity = params[:entity]
+        @check  = params[:check]
+
+        entity_check = get_entity_check(@entity, @check)
+        return 404 if entity_check.nil?
+
+        entity_check.end_unscheduled_maintenance
+
+        redirect back
+      end
+
+      # create scheduled maintenance
+      post '/scheduled_maintenances/:entity/:check' do
+        start_time = Chronic.parse(params[:start_time]).to_i
+        raise ArgumentError, "start time parsed to zero" unless start_time > 0
+        duration   = ChronicDuration.parse(params[:duration])
+        summary    = params[:summary]
+
+        entity_check = get_entity_check(params[:entity], params[:check])
+        return 404 if entity_check.nil?
+
+        entity_check.create_scheduled_maintenance(:start_time => start_time,
+                                                  :duration   => duration,
+                                                  :summary    => summary)
+        redirect back
+      end
+
+      # modify scheduled maintenance
+      patch '/scheduled_maintenances/:entity/:check' do
+        entity_check = get_entity_check(params[:entity], params[:check])
+        return 404 if entity_check.nil?
+
+        end_time   = Chronic.parse(params[:end_time]).to_i
+        start_time = params[:start_time].to_i
+        raise ArgumentError, "start time parsed to zero" unless start_time > 0
+
+        patches = {}
+        patches[:end_time] = end_time if end_time && (end_time > start_time)
+
+        raise ArgumentError.new("no valid data received to patch with") if patches.empty?
+
+        entity_check.update_scheduled_maintenance(start_time, patches)
+        redirect back
+      end
+
+      # delete a scheduled maintenance
+      delete '/scheduled_maintenances/:entity/:check' do
+        entity_check = get_entity_check(params[:entity], params[:check])
+        return 404 if entity_check.nil?
+
+        entity_check.delete_scheduled_maintenance(:start_time => params[:start_time].to_i)
+        redirect back
+      end
+
+      get '/contacts' do
+        @contacts = Flapjack::Data::Contact.all(:redis => redis)
+        haml :contacts
+      end
+
+      get "/contacts/:contact" do
+        contact_id = params[:contact]
+
+        if contact_id
+          @contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis)
+        end
+
+        unless @contact
+          status 404
+          return
+        end
+
+        if @contact.media.has_key?('pagerduty')
+          @pagerduty_credentials = @contact.pagerduty_credentials
+        end
+
+        @entities_and_checks = @contact.entities_and_checks.sort_by {|ec|
+          ec[:entity].name
+        }
+
+        haml :contact
+      end
+
+    private
+
+      def get_entity_check(entity, check)
+        entity_obj = (entity && entity.length > 0) ?
+          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)
+      end
+
+      def entity_check_state(entity_name, check)
+        entity = Flapjack::Data::Entity.find_by_name(entity_name,
+          :redis => redis)
+        return if entity.nil?
+        entity_check = Flapjack::Data::EntityCheck.for_entity(entity,
+          check, :redis => redis)
+        latest_notif =
+          {:problem         => entity_check.last_problem_notification,
+           :recovery        => entity_check.last_recovery_notification,
+           :acknowledgement => entity_check.last_acknowledgement_notification
+          }.max_by {|n| n[1] || 0}
+        [(entity_check.state       || '-'),
+         (entity_check.last_change || '-'),
+         (entity_check.last_update || '-'),
+         entity_check.in_unscheduled_maintenance?,
+         entity_check.in_scheduled_maintenance?,
+         latest_notif[0],
+         latest_notif[1]
+        ]
+      end
+
+      def self_stats
+        @fqdn         = `/bin/hostname -f`.chomp
+        @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)
+        @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
+
+    end
+
+  end
+
+end

data/lib/flapjack/pikelet.rb

@@ -61,27 +61,4 @@ module Flapjack
 
   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
-
-      if config = opts[:config]
-        @port = config['port'] ? config['port'].to_i : nil
-        @port = 3001 if (@port.nil? || @port <= 0 || @port > 65535)
-      end
-
-      orig_bootstrap(opts)
-    end
-
-  end
 end

data/lib/flapjack/version.rb

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

data/spec/lib/flapjack/coordinator_spec.rb

@@ -1,23 +1,24 @@
 require 'spec_helper'
-require 'flapjack/coordinator'
 
-describe Flapjack::Coordinator do
+require 'flapjack/configuration'
+require 'flapjack/executive'
+
+require 'flapjack/gateways/web'
+require 'flapjack/gateways/jabber'
+require 'flapjack/gateways/email'
 
-  let(:fiber) { mock('Fiber') }
+require 'flapjack/coordinator'
 
-  let(:config) {
-    {'redis'          => {},
-     'executive'      => {'enabled' => 'yes'},
-     'email_notifier' => {'enabled' => 'yes'},
-     'web'            => {'enabled' => 'yes'}
-    }
-  }
+describe Flapjack::Coordinator do
 
-  let(:redis_config) { {} }
+  let(:fiber)  { mock(Fiber) }
+  let(:config) { mock(Flapjack::Configuration) }
 
   # leaving actual testing of daemonisation to that class's tests
   it "daemonizes properly" do
-    fc = Flapjack::Coordinator.new(config, redis_config)
+    config.should_receive(:for_redis).and_return({})
+    fc = Flapjack::Coordinator.new(config)
+
     fc.should_receive(:daemonize)
     fc.should_not_receive(:build_pikelet)
     fc.start(:daemonize => true, :signals => false)
@@ -25,17 +26,24 @@ describe Flapjack::Coordinator do
 
   it "runs undaemonized" do
     EM.should_receive(:synchrony).and_yield
+    config.should_receive(:for_redis).and_return({})
+    config.should_receive(:pikelets).and_return(Flapjack::Executive => {'enabled' => 'yes'})
+    config.should_receive(:gateways).and_return({})
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
-    fc.should_receive(:build_pikelet).exactly(3).times
+    fc = Flapjack::Coordinator.new(config)
+    fc.should_receive(:build_pikelet)
     fc.start(:daemonize => false, :signals => false)
   end
 
   it "starts after daemonizing" do
     EM.should_receive(:synchrony).and_yield
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
-    fc.should_receive(:build_pikelet).exactly(3).times
+    config.should_receive(:for_redis).and_return({})
+    config.should_receive(:pikelets).and_return(Flapjack::Executive => {'enabled' => 'yes'})
+    config.should_receive(:gateways).and_return({})
+
+    fc = Flapjack::Coordinator.new(config)
+    fc.should_receive(:build_pikelet)
     fc.after_daemonize
   end
 
@@ -46,7 +54,8 @@ describe Flapjack::Coordinator do
     Kernel.should_receive(:trap).with('TERM').and_yield
     Kernel.should_receive(:trap).with('QUIT').and_yield
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
+    config.should_receive(:for_redis).and_return({})
+    fc = Flapjack::Coordinator.new(config)
     fc.should_receive(:stop).exactly(3).times
 
     fc.send(:setup_signals)
@@ -59,7 +68,8 @@ describe Flapjack::Coordinator do
     Kernel.should_receive(:trap).with('TERM').and_yield
     Kernel.should_not_receive(:trap).with('QUIT')
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
+    config.should_receive(:for_redis).and_return({})
+    fc = Flapjack::Coordinator.new(config)
     fc.should_receive(:stop).twice
 
     fc.send(:setup_signals)
@@ -78,7 +88,7 @@ describe Flapjack::Coordinator do
     email = mock('worker')
     email.should_receive(:is_a?).with(Flapjack::GenericPikelet).twice.and_return(false)
     email.should_receive(:shutdown)
-    Flapjack::Notification::Email.should_receive(:cleanup)
+    Flapjack::Gateways::Email.should_receive(:cleanup)
 
     backend = mock('backend')
     backend.should_receive(:size).twice.and_return(1, 0)
@@ -86,7 +96,7 @@ describe Flapjack::Coordinator do
     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)
+    Flapjack::Gateways::Web.should_receive(:cleanup)
 
     redis = mock('redis')
     redis.should_receive(:quit)
@@ -104,10 +114,12 @@ describe Flapjack::Coordinator do
     EM.should_receive(:stop)
 
     pikelets = [{:fiber => fiber_exec, :instance => exec, :class => Flapjack::Executive},
-                {:fiber => fiber_rsq,  :instance => email, :class => Flapjack::Notification::Email},
-                {:instance => web, :class => Flapjack::Web}]
+                {:fiber => fiber_rsq,  :instance => email, :class => Flapjack::Gateways::Email},
+                {:instance => web, :class => Flapjack::Gateways::Web}]
+
+    config.should_receive(:for_redis).and_return({})
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
+    fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@redis_options', {})
     fc.instance_variable_set('@pikelets', pikelets)
     fc.stop
@@ -123,8 +135,10 @@ describe Flapjack::Coordinator do
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
-    fc.send(:build_pikelet, 'executive', {})
+    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)
@@ -135,21 +149,23 @@ describe Flapjack::Coordinator 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)
+    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)
 
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
+    config.should_receive(:for_redis).and_return({})
+
+    fc = Flapjack::Coordinator.new(config)
     fc.should_receive(:stop)
-    fc.send(:build_pikelet, 'jabber_gateway', {})
+    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::Jabber, :instance => jabber}
+    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Gateways::Jabber, :instance => jabber}
   end
 
   it "creates a resque worker pikelet" do
@@ -164,13 +180,15 @@ describe Flapjack::Coordinator do
     fiber.should_receive(:resume)
     Fiber.should_receive(:new).and_yield.and_return(fiber)
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
-    fc.send(:build_pikelet, 'email_notifier', {})
+    config.should_receive(:for_redis).and_return({})
+
+    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::Notification::Email,
+    pikelets.first.should == {:fiber => fiber, :class => Flapjack::Gateways::Email,
                               :instance => worker}
   end
 
@@ -180,18 +198,20 @@ describe Flapjack::Coordinator do
     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::Web, :signals => false).
+      with(/^(?:\d{1,3}\.){3}\d{1,3}$/, an_instance_of(Fixnum), Flapjack::Gateways::Web, :signals => false).
       and_return(server)
 
     Flapjack::RedisPool.should_receive(:new)
 
-    fc = Flapjack::Coordinator.new(config, redis_config)
-    fc.send(:build_pikelet, 'web', {})
+    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::Web, :instance => server}
+    pikelets.first.should == {:class => Flapjack::Gateways::Web, :instance => server}
   end
 
   # NB: exceptions are handled directly by the Thin pikelets