flapjack 0.7.20 → 0.7.21

data/lib/flapjack/gateways/web.rb

@@ -39,7 +39,7 @@ module Flapjack
 
       class << self
         def start
-          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 1)
+          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
 
           @logger.info "starting web - class"
 

data/lib/flapjack/gateways/web/views/check.html.erb

@@ -180,7 +180,7 @@
             </tr>
             <% @contacts.sort_by {|c| [c.first_name, c.last_name] }.each do |contact| %>
               <tr>
-                <td><a href="/contacts/<% contact.id %>" title="contact details"><%= h contact.name %></a></td>
+                <td><a href="/contacts/<%= contact.id %>" title="contact details"><%= h contact.name %></a></td>
                 <td>
                   <% if contact.media && !contact.media.empty? %>
                     <p><%= h contact.media.keys.collect(&:capitalize).join(", ") %></p>
@@ -201,4 +201,4 @@
       <%= foot %>
     </div>
   </body>
-</html>
+</html>

data/lib/flapjack/gateways/web/views/contact.html.erb

@@ -86,7 +86,7 @@
             <tr>
               <th>ID</th>
               <th>Entities</th>
-              <th>Entity Tags</th>
+              <th>Tags</th>
               <th>Warning Media</th>
               <th>Critical Media</th>
               <th>Time Restrictions</th>
@@ -95,7 +95,7 @@
               <tr>
                 <td><%= h rule.id %></td>
                 <td><%= h( (rule.entities && !rule.entities.empty?) ? rule.entities.join(', ') : '-') %></td>
-                <td><%= h( (rule.entity_tags && !rule.entity_tags.empty?) ? rule.entity_tags.join(', ') : '-') %></td>
+                <td><%= h( (rule.tags && !rule.tags.empty?) ? rule.tags.to_a.join(', ') : '-') %></td>
                 <td><%= h( (rule.warning_media && !rule.warning_media.empty?) ? rule.warning_media.join(', ') : '-')%></td>
                 <td><%= h( (rule.critical_media && !rule.critical_media.empty?) ? rule.critical_media.join(', ') : '-') %></td>
                 <td><%= h(rule.time_restrictions) %></td>
@@ -111,4 +111,4 @@
       <%= foot %>
     </div>
   </body>
-</html>
+</html>

data/lib/flapjack/logger.rb

@@ -1,13 +1,12 @@
 #!/usr/bin/env ruby
 
 require 'logger'
+require 'syslog'
 
 begin
   # Ruby 2.0+
   require 'syslog/logger'
 rescue LoadError
-  # Ruby 1.9
-  require 'syslog'
 end
 
 module Flapjack
@@ -16,14 +15,14 @@ module Flapjack
 
     LEVELS = [:debug, :info, :warn, :error, :fatal]
 
-    # only used for 1.9
-    SYSLOG_LEVELS_MAP = {
-      :debug  => Syslog::Constants::LOG_DEBUG,
-      :info   => Syslog::Constants::LOG_INFO,
-      :warn   => Syslog::Constants::LOG_WARNING,
-      :error  => Syslog::Constants::LOG_ERR,
-      :fatal  => Syslog::Constants::LOG_CRIT
-    }
+    SEVERITY_LABELS = %w(DEBUG INFO WARN ERROR FATAL)
+
+    SYSLOG_LEVELS = [::Syslog::Constants::LOG_DEBUG,
+                     ::Syslog::Constants::LOG_INFO,
+                     ::Syslog::Constants::LOG_WARNING,
+                     ::Syslog::Constants::LOG_ERR,
+                     ::Syslog::Constants::LOG_CRIT
+                    ]
 
     def initialize(name, config = {})
       config ||= {}
@@ -31,7 +30,14 @@ module Flapjack
       @name = name
 
       @formatter = proc do |severity, datetime, progname, msg|
-        "#{datetime.iso8601} [#{severity}] :: #{name} :: #{msg}\n"
+        t = datetime.iso8601
+        "#{t} [#{severity}] :: #{name} :: #{msg}\n"
+      end
+
+      @syslog_formatter = proc do |severity, datetime, progname, msg|
+        t = datetime.iso8601
+        l = SEVERITY_LABELS[severity]
+        "#{t} [#{l}] :: #{name} :: #{msg}\n"
       end
 
       @logger = ::Logger.new(STDOUT)
@@ -40,19 +46,15 @@ module Flapjack
       if Syslog.const_defined?('Logger', false)
         # Ruby 2.0+
         @sys_logger = Syslog.const_get('Logger', false).new('flapjack')
-        @sys_logger.formatter = @formatter
-      else
-        # Ruby 1.9
-        @syslog = Syslog.opened? ? Syslog :
-                    Syslog.open('flapjack',
-                                (Syslog::Constants::LOG_PID | Syslog::Constants::LOG_CONS),
-                                Syslog::Constants::LOG_USER)
+        @sys_logger.formatter = @syslog_formatter
       end
 
       configure(config)
     end
 
     def configure(config)
+      raise "Cannot configure closed logger" if @logger.nil?
+
       level = config['level']
 
       # we'll let Logger spit the dummy on invalid level values -- but will
@@ -63,7 +65,7 @@ module Flapjack
 
       err = nil
 
-      new_level = begin
+      @level = begin
         ::Logger.const_get(level.upcase)
       rescue NameError
         err = "Unknown Logger severity level '#{level.upcase}', using INFO..."
@@ -72,32 +74,62 @@ module Flapjack
 
       @logger.error(err) if err
 
-      @logger.level = new_level
+      @logger.level = @level
       if @sys_logger
-        @sys_logger.level = new_level
-      elsif @syslog
-        Syslog.mask = Syslog::LOG_UPTO(SYSLOG_LEVELS_MAP[level.downcase.to_sym])
+        @sys_logger.level = @level
       end
+    end
 
+    def close
+      raise "Already closed" if @logger.nil?
+      @logger.close
+      @logger = nil
+      if @sys_logger
+        @sys_logger.close
+        @sys_logger = nil
+      end
     end
 
-    LEVELS.each do |level|
-      define_method(level) {|*args, &block|
-        @logger.send(level.to_sym, *args, &block)
-        if @sys_logger
-          @sys_logger.send(level.to_sym, *args, &block)
-        elsif @syslog
-          t = Time.now.iso8601
-          l = level.to_s.upcase
-          @syslog.log(SYSLOG_LEVELS_MAP[level],
-                      "#{t} [#{l}] :: #{@name} :: %s",
-                      (block ? block.call : args.first))
+    def add(severity, message = nil, progname = nil, &block)
+      raise "Cannot log with a closed logger" if @logger.nil?
+      @logger.add(severity, message, progname, &block)
+      return if severity < @level
+
+      progname ||= 'flapjack'
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = 'flapjack'
         end
+      end
+
+      if @sys_logger
+        @sys_logger.add(severity, message, progname, &block)
+      else
+        level = SYSLOG_LEVELS[severity]
+        t = Time.now.iso8601
+        l = SEVERITY_LABELS[severity]
+        begin
+          Syslog.open('flapjack', (Syslog::Constants::LOG_PID | Syslog::Constants::LOG_CONS),
+                                   Syslog::Constants::LOG_USER)
+          Syslog.mask = Syslog::LOG_UPTO(level)
+          Syslog.log(level, "#{t} [#{l}] :: #{@name} :: %s", message)
+        ensure
+          Syslog.close
+        end
+      end
+    end
+
+    LEVELS.each do |level|
+      define_method(level) {|progname, &block|
+        add(::Logger.const_get(level.upcase), nil, progname, &block)
       }
     end
 
     def respond_to?(sym)
-      (LEVELS + [:configure]).include?(sym)
+      (LEVELS + [:configure, :close, :add]).include?(sym)
     end
 
   end

data/lib/flapjack/notifier.rb

@@ -2,6 +2,8 @@
 
 require 'active_support/time'
 
+require 'em-hiredis'
+
 require 'oj'
 
 require 'flapjack/data/contact'
@@ -22,9 +24,9 @@ module Flapjack
 
     def initialize(opts = {})
       @config = opts[:config]
-      @redis_config = opts[:redis_config]
+      @redis_config = opts[:redis_config] || {}
       @logger = opts[:logger]
-      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2) # first will block
+      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
 
       @notifications_queue = @config['queue'] || 'notifications'
 
@@ -73,7 +75,11 @@ module Flapjack
     # from a different fiber while the main one is blocking.
     def stop
       @should_quit = true
-      @redis.rpush(@notifications_queue, Oj.dump('type' => 'shutdown'))
+
+      redis_uri = @redis_config[:path] ||
+        "redis://#{@redis_config[:host] || '127.0.0.1'}:#{@redis_config[:port] || '6379'}/#{@redis_config[:db] || '0'}"
+      shutdown_redis = EM::Hiredis.connect(redis_uri)
+      shutdown_redis.rpush(@notifications_queue, Oj.dump('type' => 'shutdown'))
     end
 
   private

data/lib/flapjack/pikelet.rb

@@ -73,6 +73,7 @@ module Flapjack
         @config = opts[:config] || {}
         @redis_config = opts[:redis_config] || {}
         @boot_time = opts[:boot_time]
+        @coordinator = opts[:coordinator]
 
         @logger = Flapjack::Logger.new("flapjack-#{type}", @config['logger'])
 
@@ -104,7 +105,8 @@ module Flapjack
       def self.create(type, opts = {})
         self.new(type, PIKELET_TYPES[type], :config => opts[:config],
           :redis_config => opts[:redis_config],
-          :boot_time => opts[:boot_time])
+          :boot_time => opts[:boot_time],
+          :coordinator => opts[:coordinator])
       end
 
       def initialize(type, pikelet_klass, opts = {})

data/lib/flapjack/processor.rb

@@ -2,6 +2,8 @@
 
 require 'chronic_duration'
 
+require 'em-hiredis'
+
 require 'flapjack/filters/acknowledgement'
 require 'flapjack/filters/ok'
 require 'flapjack/filters/scheduled_maintenance'
@@ -22,9 +24,11 @@ module Flapjack
 
     def initialize(opts = {})
       @config = opts[:config]
-      @redis_config = opts[:redis_config]
+      @redis_config = opts[:redis_config] || {}
       @logger = opts[:logger]
-      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2) # first will block
+      @coordinator = opts[:coordinator]
+
+      @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
 
       @queue = @config['queue'] || 'events'
 
@@ -36,6 +40,8 @@ module Flapjack
       ncsm_duration_conf = @config['new_check_scheduled_maintenance_duration'] || '100 years'
       @ncsm_duration = ChronicDuration.parse(ncsm_duration_conf)
 
+      @exit_on_queue_empty = !! @config['exit_on_queue_empty']
+
       options = { :logger => opts[:logger], :redis => @redis }
       @filters = []
       @filters << Flapjack::Filters::Ok.new(options)
@@ -94,7 +100,18 @@ module Flapjack
                                            :redis => @redis,
                                            :archive_events => @archive_events,
                                            :events_archive_maxage => @events_archive_maxage,
-                                           :logger => @logger)
+                                           :logger => @logger,
+                                           :block => ! @exit_on_queue_empty )
+        if @exit_on_queue_empty && event.nil? && Flapjack::Data::Event.pending_count(@queue, :redis => @redis)
+          # SHUT IT ALL DOWN!!!
+          @logger.warn "Shutting down as exit_on_queue_empty is true, and the queue is empty"
+          @should_quit = true
+          @coordinator.stop
+          # FIXME: seems the above call doesn't block until the remove_pikelets fiber exits...
+          EM::Synchrony.sleep(1)
+          exit
+        end
+
         process_event(event) unless event.nil?
       end
 
@@ -104,20 +121,25 @@ module Flapjack
     # this must use a separate connection to the main Executive one, as it's running
     # from a different fiber while the main one is blocking.
     def stop
-      @should_quit = true
-      @redis.rpush('events', Oj.dump('type'    => 'shutdown',
-                                     'host'    => '',
-                                     'service' => '',
-                                     'state'   => ''))
+      unless @should_quit
+        @should_quit = true
+        redis_uri = @redis_config[:path] ||
+          "redis://#{@redis_config[:host] || '127.0.0.1'}:#{@redis_config[:port] || '6379'}/#{@redis_config[:db] || '0'}"
+        shutdown_redis = EM::Hiredis.connect(redis_uri)
+        shutdown_redis.rpush('events', Oj.dump('type' => 'noop'))
+      end
     end
 
   private
 
     def process_event(event)
-      pending = Flapjack::Data::Event.pending_count(:redis => @redis)
+      pending = Flapjack::Data::Event.pending_count(@queue, :redis => @redis)
       @logger.debug("#{pending} events waiting on the queue")
       @logger.debug("Raw event received: #{event.inspect}")
-      return if ('shutdown' == event.type)
+
+      if ('noop' == event.type)
+        return
+      end
 
       event_str = "#{event.id}, #{event.type}, #{event.state}, #{event.summary}"
       event_str << ", #{Time.at(event.time).to_s}" if event.time
@@ -126,6 +148,8 @@ module Flapjack
       entity_check = Flapjack::Data::EntityCheck.for_event_id(event.id, :redis => @redis)
       timestamp = Time.now.to_i
 
+      event.tags = (event.tags || Flapjack::Data::TagSet.new) + entity_check.tags
+
       should_notify = update_keys(event, entity_check, timestamp)
 
       if !should_notify

data/lib/flapjack/version.rb

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

data/spec/lib/flapjack/coordinator_spec.rb

@@ -7,9 +7,9 @@ describe Flapjack::Coordinator do
   let(:fiber)  { mock(Fiber) }
   let(:config) { mock(Flapjack::Configuration) }
 
-  let(:logger)     { mock(Flapjack::Logger) }
+  let(:logger) { mock(Flapjack::Logger) }
 
-  let!(:time)   { Time.now }
+  let!(:time)  { Time.now }
 
   it "starts and stops a pikelet" do
     Flapjack::Logger.should_receive(:new).and_return(logger)
@@ -29,7 +29,7 @@ describe Flapjack::Coordinator do
 
     fc = Flapjack::Coordinator.new(config)
     Flapjack::Pikelet.should_receive(:create).with('processor',
-        :config => cfg['processor'], :redis_config => {}, :boot_time => time).
+        :config => cfg['processor'], :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(processor)
 
     fiber.should_receive(:resume)
@@ -63,7 +63,7 @@ describe Flapjack::Coordinator do
 
     fc = Flapjack::Coordinator.new(config)
     Flapjack::Pikelet.should_receive(:create).with('processor',
-        :config => cfg['processor'], :redis_config => {}, :boot_time => time)
+        :config => cfg['processor'], :redis_config => {}, :boot_time => time, :coordinator => fc)
       .and_return(processor)
 
     fiber.should_receive(:resume)
@@ -100,10 +100,10 @@ describe Flapjack::Coordinator do
 
     fc = Flapjack::Coordinator.new(config)
     Flapjack::Pikelet.should_receive(:create).with('processor',
-        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
+        :config => cfg['executive'], :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(processor)
     Flapjack::Pikelet.should_receive(:create).with('notifier',
-        :config => cfg['executive'], :redis_config => {}, :boot_time => time).
+        :config => cfg['executive'], :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(notifier)
 
     fiber.should_receive(:resume)
@@ -138,7 +138,7 @@ describe Flapjack::Coordinator do
     fc = Flapjack::Coordinator.new(config)
     Flapjack::Pikelet.should_receive(:create).with('processor',
         :config => cfg['executive'].merge(cfg['processor']),
-        :redis_config => {}, :boot_time => time).
+        :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(processor)
 
     fiber.should_receive(:resume)
@@ -210,22 +210,25 @@ describe Flapjack::Coordinator do
     processor.should_receive(:update_status)
     processor.should_receive(:status).exactly(3).times.and_return('stopped')
 
+    config.should_receive(:for_redis).and_return({})
+    fc = Flapjack::Coordinator.new(config)
+
     jabber = mock('jabber')
     Flapjack::Pikelet.should_receive(:create).
       with('jabber', :config => {"enabled" => true}, :redis_config => {},
-        :boot_time => time).
+        :boot_time => time, :coordinator => fc).
       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.instance_variable_set('@boot_time', time)
     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
@@ -287,13 +290,14 @@ describe Flapjack::Coordinator do
     new_exec = mock('new_executive')
     new_exec.should_receive(:start)
 
+    config.should_receive(:for_redis).and_return({})
+    fc = Flapjack::Coordinator.new(config)
+
     Flapjack::Pikelet.should_receive(:create).
       with('processor', :config => new_cfg['processor'], :redis_config => {},
-        :boot_time => time).
+        :boot_time => time, :coordinator => fc).
       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', [processor])
     fc.reload