flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/gateways/email/alert.html.erb

@@ -11,20 +11,16 @@
   }
 </style>
 
-<p>Hi <%= @alert.contact_first_name%></p>
+<p>Hi <%= @alert.medium.contact.name %></p>
 
 <p>Monitoring has detected the following:</p>
 
+<% check = @alert.check -%>
 <table>
   <tbody>
-    <tr>
-      <td><strong>Entity</strong></td>
-      <td><%= @alert.entity %></td>
-    </tr>
-
     <tr>
       <td><strong>Check</strong></td>
-      <td><%= @alert.check %></td>
+      <td><%= check.name %></td>
     </tr>
 
     <tr>
@@ -32,45 +28,50 @@
       <td><%= @alert.state_title_case %></td>
     </tr>
 
-    <% if @alert.summary %>
+    <% summary = @alert.summary -%>
+    <% unless summary.nil? || summary.empty? -%>
       <tr>
         <td><strong>Summary</strong></td>
-        <td><%= @alert.summary %></td>
+        <td><%= summary %></td>
       </tr>
     <% end %>
 
-    <% if @alert.details %>
+    <% details = @alert.details -%>
+    <% unless details.nil? || details.empty? -%>
       <tr>
         <td><strong>Details</strong></td>
-        <td><%= @alert.details %></td>
+        <td><%= details %></td>
       </tr>
     <% end %>
 
-    <% if @alert.time %>
+    <% time = @alert.time -%>
+    <% unless time.nil? -%>
       <tr>
         <td><strong>Time</strong></td>
-        <td><%= Time.at(@alert.time.to_i).to_s %></td>
+        <td><%= Time.at(time.to_i).to_s %></td>
       </tr>
     <% end %>
 
-    <% if @alert.state_duration && @alert.state_duration > 40 %>
+    <% condition_duration = @alert.condition_duration -%>
+    <% unless condition_duration.nil? || (condition_duration <= 40.0) -%>
       <tr>
         <td><strong>Duration</strong></td>
-        <td><%= ChronicDuration.output(@alert.state_duration, :keep_zero => true) || '0 secs' %></td>
+        <td><%= ChronicDuration.output(condition_duration, :keep_zero => true) || '0 secs' %></td>
       </tr>
     <% end %>
 
-    <% if @alert.last_state %>
+    <% unless @alert.last_state.nil? -%>
       <tr>
         <td><strong>Previous State</strong></td>
         <td><%= @alert.last_state_title_case %></td>
       </tr>
     <% end %>
 
-    <% if @alert.last_summary %>
+    <% last_summary = @alert.last_summary -%>
+    <% unless last_summary.nil? || last_summary.empty? -%>
       <tr>
         <td><strong>Previous Summary</strong></td>
-        <td><%= @alert.last_summary %></td>
+        <td><%= last_summary %></td>
       </tr>
     <% end %>
 

data/lib/flapjack/gateways/email/alert.text.erb

@@ -1,27 +1,33 @@
-Hi <%= @alert.contact_first_name %>
+Hi <%= @alert.medium.contact.name %>
 
 Monitoring has detected the following:
 
-Entity:           <%= @alert.entity %>
-Check:            <%= @alert.check %>
+<% check = @alert.check -%>
+
+Check:            <%= check.name %>
 State:            <%= @alert.state_title_case %>
-<% if @alert.summary -%>
-Summary:          <%= @alert.summary %>
+<% summary = @alert.summary -%>
+<% unless summary.nil? || summary.empty? -%>
+Summary:          <%= summary %>
 <% end -%>
-<% if @alert.details -%>
-Details:          <%= @alert.details %>
+<% details = @alert.details -%>
+<% unless details.nil? || details.empty? -%>
+Details:          <%= details %>
 <% end -%>
-<% if @alert.time -%>
-Time:             <%= Time.at(@alert.time.to_i).to_s %>
+<% time = @alert.time -%>
+<% unless time.nil? -%>
+Time:             <%= Time.at(time.to_i).to_s %>
 <% end -%>
-<% if @alert.state_duration && @alert.state_duration > 40 -%>
-Duration:         <%= ChronicDuration.output(@alert.state_duration, :keep_zero => true) || '0 secs' %>
+<% condition_duration = @alert.condition_duration -%>
+<% unless condition_duration.nil? || (condition_duration <= 40) -%>
+Duration:         <%= ChronicDuration.output(condition_duration, :keep_zero => true) || '0 secs' %>
 <% end -%>
-<% if @alert.last_state -%>
+<% unless @alert.last_state.nil? -%>
 Previous State:   <%= @alert.last_state_title_case %>
 <% end -%>
-<% if @alert.last_summary -%>
-Previous Summary: <%= @alert.last_summary %>
+<% last_summary = @alert.last_summary -%>
+<% unless last_summary.nil? || last_summary.empty? -%>
+Previous Summary: <%= last_summary %>
 <% end -%>
 
 Cheers,

data/lib/flapjack/gateways/email/alert_subject.text.erb

@@ -1,4 +1,5 @@
-<%= @alert.type_sentence_case %>: '<%= @alert.check %>' on <%= @alert.entity -%>
+<% check = @alert.check -%>
+<%= @alert.type_sentence_case %>: '<%= check.name %>'
 <% unless ['acknowledgement', 'test'].include?(@alert.notification_type) -%>
  is <%= @alert.state_title_case -%>
 <% end -%>

data/lib/flapjack/gateways/email/rollup.html.erb

@@ -11,27 +11,27 @@
   }
 </style>
 
-<p>Hi <%= @alert.contact_first_name %></p>
+<p>Hi <%= @alert.contact_name %></p>
 
-<p>You have <%= @alert.rollup_alerts.length %> alerting check<%= @alert.rollup_alerts.length == 1 ? '' : 's' %> as follows:</p>
+<% rollup_alerts_count = @alert.rollup_alerts.length -%>
+<p>You have <%= rollup_alerts_count %> alerting check<%= (rollup_alerts_count == 1) ? '' : 's' %> as follows:</p>
 
 <table>
   <tbody>
     <tr>
       <th>Check</th>
-      <th>Entity</th>
       <th>State</th>
       <th>Duration</th>
       <th>Summary</th>
     </tr>
-<%  @alert.rollup_alerts.sort_by {|entity_check, details| details['duration'] }.each do |rollup_alert| -%>
-<%    r_entity, r_check = rollup_alert[0].split(':', 2) -%>
-<%    state    = rollup_alert[1]['state'] -%>
-<%    duration = (ChronicDuration.output(rollup_alert[1]['duration'], :keep_zero => true) || '0 secs') -%>
-<%    summary = rollup_alert[1]['summary'] -%>
+
+<%  @alert.rollup_alerts.all.sort_by(&:duration).each do |rollup_alert|
+      check    = rollup_alert.check
+      state    = rollup_alert.state
+      duration = (ChronicDuration.output(rollup_alert.duration, :keep_zero => true) || '0 secs') -%>
+      summary  = rollup_alert.summary
       <tr>
-        <td><%= r_check %></td>
-        <td><%= r_entity %></td>
+        <td><%= check.name %></td>
         <td><%= ['ok'].include?(state) ? state.upcase : state.titleize %></td>
         <td><%= duration %></td>
         <td><%= summary %></td>
@@ -40,10 +40,11 @@
   </tbody>
 </table>
 
-<% if @alert.rollup == 'recovery' %>
-  <p>As your email summary threshold is <%= @alert.rollup_threshold %>, we're taking your email alerts out of summary mode now. You'll now be emailed individually for each alerting check.</p>
+<% rollup_threshold = @alert.medium.rollup_threshold -%>
+<% if 'recovery'.eql?(@alert.rollup) %>
+  <p>As your email summary threshold is <%= rollup_threshold %>, we're taking your email alerts out of summary mode now. You'll now be emailed individually for each alerting check.</p>
 <% else %>
-  <p>Your email alerts are being summarised as your email summary threshold is set to <%= @alert.rollup_threshold %>. You'll receive summary emails like this one until your number of alerting checks falls below <%= @alert.rollup_threshold %>.</p>
+  <p>Your email alerts are being summarised as your email summary threshold is set to <%= rollup_threshold %>. You'll receive summary emails like this one until your number of alerting checks falls below <%= rollup_threshold %>.</p>
 <% end %>
 
 <p>Cheers,<br/>

data/lib/flapjack/gateways/email/rollup.text.erb

@@ -1,18 +1,21 @@
-Hi <%= @alert.contact_first_name %>
+Hi <%= @alert.contact_name %>
 
-You have <%= @alert.rollup_alerts.length %> alerting check<%= @alert.rollup_alerts.length == 1 ? '' : 's' %> as follows:
+<% rollup_alerts_count = @alert.rollup_alerts.length %>
 
-<% @alert.rollup_alerts.sort_by {|entity_check, details| details['duration'] }.each do |rollup_alert| -%>
-<%   r_entity, r_check = rollup_alert[0].split(':', 2) -%>
-<%   state    = rollup_alert[1]['state'] -%>
-<%   duration = (ChronicDuration.output(rollup_alert[1]['duration'], :keep_zero => true) || '0 secs') -%>
-  * <%= r_check %> on <%= r_entity %> is <%= ['ok'].include?(state) ? state.upcase : state.titleize %> (<%= duration %>)
+You have <%= rollup_alerts_count %> alerting check<%= rollup_alerts_count == 1 ? '' : 's' %> as follows:
+
+<%  @alert.rollup_alerts.all.sort_by(&:duration).each do |rollup_alert|
+      check    = rollup_alert.check
+      state    = rollup_alert.state
+      duration = (ChronicDuration.output(rollup_alert.duration, :keep_zero => true) || '0 secs') -%>
+  * <%= check.name %> is <%= ['ok'].include?(state) ? state.upcase : state.titleize %> (<%= duration %>)
 <% end -%>
 
-<% if @alert.rollup == 'recovery' -%>
-As your email summary threshold is <%= @alert.rollup_threshold %>, we're taking your email alerts out of summary mode now. You'll now be emailed individually for each alerting check.
+<% rollup_threshold = @alert.medium.rollup_threshold -%>
+<% if 'recovery'.eql?(@alert.rollup) -%>
+As your email summary threshold is <%= rollup_threshold %>, we're taking your email alerts out of summary mode now. You'll now be emailed individually for each alerting check.
 <% else -%>
-Your email alerts are being summarised as your email summary threshold is set to <%= @alert.rollup_threshold %>. You'll receive summary emails like this one until your number of alerting checks falls below <%= @alert.rollup_threshold %>.
+Your email alerts are being summarised as your email summary threshold is set to <%= rollup_threshold %>. You'll receive summary emails like this one until your number of alerting checks falls below <%= rollup_threshold %>.
 <% end -%>
 
 Cheers,

data/lib/flapjack/gateways/jabber.rb

@@ -1,823 +1,831 @@
 #!/usr/bin/env ruby
 
-require 'em-hiredis'
-
+require 'monitor'
 require 'socket'
 
-require 'blather/client/client'
 require 'chronic_duration'
+require 'rexml/document'
+require 'xmpp4r/query'
+require 'xmpp4r/muc'
 
-require 'flapjack/data/entity_check'
-require 'flapjack/redis_pool'
+require 'flapjack/redis_proxy'
+require 'flapjack/record_queue'
 require 'flapjack/utility'
+require 'flapjack/exceptions'
 require 'flapjack/version'
+
 require 'flapjack/data/alert'
+require 'flapjack/data/check'
+require 'flapjack/data/event'
+require 'flapjack/data/scheduled_maintenance'
+require 'flapjack/data/unscheduled_maintenance'
+require 'flapjack/data/tag'
+
 
 module Flapjack
 
   module Gateways
 
-    class Jabber < Blather::Client
-      include Flapjack::Utility
+    module Jabber
 
-      log = ::Logger.new(STDOUT)
-      log.level = ::Logger::INFO
-      Blather.logger = log
+      class Notifier
 
-      class TextHandler < Nokogiri::XML::SAX::Document
-        def initialize
-          @chunks = []
-        end
+        include Flapjack::Utility
 
-        attr_reader :chunks
+        attr_accessor :siblings
 
-        def cdata_block(string)
-          characters(string)
-        end
+        def initialize(options = {})
+          @lock = options[:lock]
+          @config = options[:config]
 
-        def characters(string)
-          @chunks << string.strip if string.strip != ""
+          # TODO support for config reloading
+          @queue = Flapjack::RecordQueue.new(@config['queue'] || 'jabber_notifications',
+                     Flapjack::Data::Alert)
         end
-      end
 
-      def initialize(opts = {})
-        @config = opts[:config]
-        @redis_config = opts[:redis_config] || {}
-        @boot_time = opts[:boot_time]
+        def start
+          begin
+            Zermelo.redis = Flapjack.redis
 
-        @logger = opts[:logger]
+            loop do
+              @lock.synchronize do
+                @queue.foreach {|alert| handle_alert(alert) }
+              end
 
-        @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2, :logger => @logger)
+              @queue.wait
+            end
+          ensure
+            Flapjack.redis.quit
+          end
+        end
 
-        @logger.debug("Jabber Initializing")
+        def stop_type
+          :exception
+        end
 
-        @buffer = []
-        @hostname = Socket.gethostname
+        private
 
-        # FIXME: i suspect the following should be in #setup so a config reload updates @identifiers
-        # I moved it here so the rspec passes :-/
-        @alias = @config['alias'] || 'flapjack'
-        @identifiers = ((@config['identifiers'] || []) + [@alias]).uniq
-        @logger.debug("I will respond to the following identifiers: #{@identifiers.join(', ')}")
+        def handle_alert(alert)
+          @bot ||= @siblings && @siblings.detect {|sib| sib.respond_to?(:announce) }
 
-        super()
-      end
+          if @bot.nil?
+            Flapjack.logger.warn("jabber bot not running, won't announce")
+            return
+          end
 
-      def stop
-        @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(@config['queue'], Flapjack.dump_json('notification_type' => 'shutdown'))
-      end
+          check = alert.check
+          check_name = check.name
 
-      def setup
-        jid = @config['jabberid'] || 'flapjack'
-        jid += '/' + @hostname unless jid.include?('/')
-        @flapjack_jid = Blather::JID.new(jid)
+          address = alert.address
+          state = alert.state
 
-        super(@flapjack_jid, @config['password'], @config['server'], @config['port'].to_i)
+          Flapjack.logger.debug("processing jabber notification address: #{address}, " +
+                        "check: '#{check_name}', state: #{state}, summary: #{alert.summary}")
 
-        @logger.debug("Building jabber connection with jabberid: " +
-          @flapjack_jid.to_s + ", port: " + @config['port'].to_s +
-          ", server: " + @config['server'].to_s + ", password: " +
-          @config['password'].to_s)
+          # event_count = alert.event_count
 
-        register_handler :ready do |stanza|
-          EventMachine::Synchrony.next_tick do
-            on_ready(stanza)
+          @ack_str = if state.eql?('ok') || ['test', 'acknowledgement'].include?(alert.type)
+            nil
+          else
+            "#{@bot.alias}: ACKID #{alert.event_hash}"
           end
-        end
 
-        body_matchers = @identifiers.inject([]) do |memo, identifier|
-          @logger.debug("identifier: #{identifier}, memo: #{memo}")
-          memo << {:body => /^#{identifier}[:\s]/}
-          memo
-        end
-        @logger.debug("body_matchers: #{body_matchers}")
-        register_handler :message, :groupchat?, body_matchers do |stanza|
-          EventMachine::Synchrony.next_tick do
-            on_groupchat(stanza)
-          end
-        end
+          message_type = alert.rollup ? 'rollup' : 'alert'
 
-        register_handler :message, :chat?, :body do |stanza|
-          EventMachine::Synchrony.next_tick do
-            on_chat(stanza)
-          end
-        end
+          message_template_erb, message_template =
+            load_template(@config['templates'], message_type,
+              'text', File.join(File.dirname(__FILE__), 'jabber'))
 
-        register_handler :disconnected do |stanza|
-          ret = true
-          EventMachine::Synchrony.next_tick do
-            ret = on_disconnect(stanza)
-          end
-          ret
-        end
-      end
+          @alert = alert
+          bnd = binding
 
-      # Join the MUC Chat room after connecting.
-      def on_ready(stanza)
-        return if @should_quit
-        @connected_at = Time.now.to_i
-        @logger.info("Jabber Connected")
-        if @config['rooms'] && @config['rooms'].length > 0
-          @config['rooms'].each do |room|
-            @logger.info("Joining room #{room}")
-            presence = Blather::Stanza::Presence.new
-            presence.from = @flapjack_jid
-            presence.to = Blather::JID.new("#{room}/#{@alias}")
-            presence << "<x xmlns='http://jabber.org/protocol/muc'><history maxstanzas='0'></x>"
-            EventMachine::Synchrony.next_tick do
-              write presence
-              say(room, "flapjack's jabber gateway started at #{Time.now}, hello! Try typing 'help'.", :groupchat)
-            end
-          end
-        end
-        return if @buffer.empty?
-        while stanza = @buffer.shift
-          @logger.debug("Sending a buffered jabber message to: #{stanza.to}, using: #{stanza.type}, message: #{stanza.body}")
-          EventMachine::Synchrony.next_tick do
-            write(stanza)
+          message = nil
+          begin
+            message = message_template_erb.result(bnd).chomp
+          rescue
+            Flapjack.logger.error "Error while executing the ERB for a jabber message, " +
+              "ERB being executed: #{message_template}"
+            raise
           end
+
+          # FIXME: should also check if presence has been established in any group chat rooms that are
+          # configured before starting to process events, otherwise the first few may get lost (send
+          # before joining the group chat rooms)
+          @bot.announce(address, message)
         end
+
       end
 
-      def get_check_details(entity_check, current_time)
-        sched   = entity_check.current_maintenance(:scheduled => true)
-        unsched = entity_check.current_maintenance(:unscheduled => true)
-        out = ''
+      class Interpreter
 
-        if sched.nil? && unsched.nil?
-          out += "Not in scheduled or unscheduled maintenance.\n"
-        else
-          if sched.nil?
-            out += "Not in scheduled maintenance.\n"
-          else
-            start  = Time.at(sched[:start_time])
-            finish = Time.at(sched[:start_time] + sched[:duration])
-            remain = time_period_in_words( (finish - current_time).ceil )
-            # TODO a simpler time format?
-            out += "In scheduled maintenance: #{start} -> #{finish} (#{remain} remaining)\n"
-          end
+        CHECK_MATCH_FRAGMENT = "(?:checks\s+(?:matching\s+\/(.+?)\/|with\s+tag\s+(.+?))|(.+?))"
 
-          if unsched.nil?
-            out += "Not in unscheduled maintenance.\n"
-          else
-            start  = Time.at(unsched[:start_time])
-            finish = Time.at(unsched[:start_time] + unsched[:duration])
-            remain = time_period_in_words( (finish - current_time).ceil )
-            # TODO a simpler time format?
-            out += "In unscheduled maintenance: #{start} -> #{finish} (#{remain} remaining)\n"
-          end
-        end
+        attr_accessor :siblings
 
-        out
-      end
+        include Flapjack::Utility
 
-      def interpreter(command_raw, from)
-        msg          = nil
-        action       = nil
-        entity_check = nil
-
-        th = TextHandler.new
-        parser = Nokogiri::HTML::SAX::Parser.new(th)
-        parser.parse(command_raw)
-        command = th.chunks.join(' ')
-
-        case command
-        when /^ACKID\s+([0-9A-F]+)(?:\s*(.*?)(?:\s*duration:.*?(\w+.*))?)$/im
-          ackid        = $1
-          comment      = $2
-          duration_str = $3
-
-          error = nil
-          dur   = nil
-
-          if comment.nil? || (comment.length == 0)
-            error = "please provide a comment, eg \"#{@config['alias']}: ACKID #{$1} AL looking\""
-          elsif duration_str
-            # a fairly liberal match above, we'll let chronic_duration do the heavy lifting
-            dur = ChronicDuration.parse(duration_str)
-          end
+        def initialize(opts = {})
+          @lock = opts[:lock]
+          @stop_cond = opts[:stop_condition]
+          @config = opts[:config]
 
-          four_hours = 4 * 60 * 60
-          duration = (dur.nil? || (dur <= 0)) ? four_hours : dur
+          @boot_time = opts[:boot_time]
 
-          event_id = @redis.hget('checks_by_hash', ackid)
+          @should_quit = false
 
-          if event_id.nil?
-            error = "not found"
-          else
-            entity_check = Flapjack::Data::EntityCheck.for_event_id(event_id, :redis => @redis)
-            error = "unknown entity" if entity_check.nil?
-          end
+          @messages = []
+        end
 
-          if error
-            msg = "ERROR - couldn't ACK #{ackid} - #{error}"
-          else
-            entity_name, check = event_id.split(':', 2)
+        def start
+          Zermelo.redis = Flapjack.redis
 
-            if entity_check.in_unscheduled_maintenance?
-              # ack = entity_check.current_maintenance(:unscheduled => true)
-              # FIXME details from current?
-              msg = "Changing ACK for #{check} on #{entity_name} (#{ackid})"
-            else
-              msg = "ACKing #{check} on #{entity_name} (#{ackid})"
+          @lock.synchronize do
+
+            @bot = self.siblings ? self.siblings.detect {|sib| sib.respond_to?(:announce)} : nil
+
+            until @messages.empty? && @should_quit
+              while msg = @messages.pop
+                Flapjack.logger.info "interpreter received #{msg.inspect}"
+                interpret(msg[:room], msg[:nick], msg[:time], msg[:message])
+              end
+              @stop_cond.wait_while { @messages.empty? && !@should_quit }
             end
-            action = Proc.new {
-              Flapjack::Data::Event.create_acknowledgement(
-                entity_name, check,
-                :summary => (comment || ''),
-                :acknowledgement_id => ackid,
-                :duration => duration,
-                :redis => @redis
-              )
-            }
           end
+          Flapjack.redis.quit
+        end
 
-        when /^help$/i
-          msg = "commands: \n" +
-                "  ACKID <id> <comment> [duration: <time spec>]\n" +
-                "  ack entities /pattern/ <comment> [duration: <time spec>]\n" +
-                "  maint entities /pattern/ <comment> [(start-in|start-at): <time spec>] [duration: <time spec>]\n" +
-                "  status entities /pattern/\n" +
-                "  ack checks /check_pattern/ on /entity_pattern/ <comment> [duration: <time spec>]\n" +
-                "  status checks /check_pattern/ on /entity_pattern/\n" +
-                "  find entities matching /pattern/\n" +
-                "  find checks[ matching /pattern/] on (<entity>|entities matching /pattern/)\n" +
-                "  test notifications for <entity>[:<check>]\n" +
-                "  tell me about <entity>[:<check>]\n" +
-                "  identify\n" +
-                "  help\n"
-
-        when /^identify$/i
-          t    = Process.times
-          fqdn = `/bin/hostname -f`.chomp
-          pid  = Process.pid
-          msg  = "Flapjack #{Flapjack::VERSION} process #{pid} on #{fqdn}\n" +
-                 "Identifiers: #{@identifiers.join(', ')}\n" +
-                 "Boot time: #{@boot_time}\n" +
-                 "User CPU Time: #{t.utime}\n" +
-                 "System CPU Time: #{t.stime}\n" +
-                 `uname -a`.chomp + "\n"
-
-        when /^test notifications for\s+([a-z0-9\-\.]+)(?::(.+))?$/im
-          entity_name = $1
-          check_name  = $2 || 'test'
-
-          if entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => @redis)
-            msg = "so you want me to test notifications for entity: #{entity_name}, check: #{check_name} eh? ... well OK!"
-
-            summary = "Testing notifications to all contacts interested in entity: #{entity_name}, check: #{check_name}"
-            Flapjack::Data::Event.test_notifications(entity_name, check_name, :summary => summary, :redis => @redis)
-          else
-            msg = "yeah, no I can't see #{entity_name} in my systems"
+        def stop_type
+          :signal
+        end
+
+        def receive_message(room, nick, time, msg)
+          @lock.synchronize do
+            @messages += [{:room => room, :nick => nick, :time => time, :message => msg}]
+            @stop_cond.signal
           end
+        end
 
-        when /^tell me about\s+([a-z0-9\-\.]+)(?::(.+))?$+/im
-          entity_name = $1
-          check_name  = $2
+        def get_check_details(check, at_time)
+          start_range = Zermelo::Filters::IndexRange.new(nil, at_time, :by_score => true)
+          end_range   = Zermelo::Filters::IndexRange.new(at_time, nil, :by_score => true)
 
-          if entity = Flapjack::Data::Entity.find_by_name(entity_name, :redis => @redis)
-            check_str = check_name.nil? ? '' : ", check: #{check_name}"
-            msg = "so you'd like details on entity: #{entity_name}#{check_str} hmm? ... OK!\n"
+          sched = check.scheduled_maintenances.intersect(:start_time => start_range,
+                    :end_time => end_range).all.max_by(&:end_time)
 
-            current_time = Time.now
+          unsched = check.unscheduled_maintenances.intersect(:start_time => start_range,
+                    :end_time => end_range).all.max_by(&:end_time)
 
-            check_names = check_name.nil? ? entity.check_list.sort : [check_name]
+          out = ''
 
-            if check_names.empty?
-              msg += "I couldn't find any checks for entity: #{entity_name}"
+          if sched.nil? && unsched.nil?
+            out += "Not in scheduled or unscheduled maintenance.\n"
+          else
+            if sched.nil?
+              out += "Not in scheduled maintenance.\n"
             else
-              check_names.each do |check|
-                entity_check = Flapjack::Data::EntityCheck.for_entity(entity, check, :redis => @redis)
-                next if entity_check.nil?
-                msg += "---\n#{entity_name}:#{check}\n" if check_name.nil?
-                msg += get_check_details(entity_check, current_time)
-              end
+              remain = time_period_in_words( (sched.end_time - at_time).ceil )
+              # TODO a simpler time format?
+              out += "In scheduled maintenance: #{sched.start_time} -> #{sched.end_time} (#{remain} remaining)\n"
+            end
+
+            if unsched.nil?
+              out += "Not in unscheduled maintenance.\n"
+            else
+              remain = time_period_in_words( (unsched.end_time - at_time).ceil )
+              # TODO a simpler time format?
+              out += "In unscheduled maintenance: #{unsched.start_time} -> #{unsched.end_time} (#{remain} remaining)\n"
             end
-          else
-            msg = "hmmm, I can't see #{entity_name} in my systems"
           end
 
-        when /^(?:find )?checks(?:\s+matching\s+\/(.+)\/)?\s+on\s+(?:entities matching\s+\/(.+)\/|([a-z0-9\-\.]+))/im
-          check_pattern  = $1 ? $1.strip : nil
-          entity_pattern = $2 ? $2.strip : nil
-          entity_name    = $3
+          out
+        end
 
-          entity_names = if entity_name
-            [entity_name]
-          elsif entity_pattern
-            Flapjack::Data::Entity.find_all_name_matching(entity_pattern, :redis => @redis)
-          else
-            []
-          end
+        def derive_check_ids_for(pattern, tag_name, check_name, options = {})
+          lock_klasses = options[:lock_klasses] || []
 
-          msg = ""
+          deriver = if !pattern.nil? && !pattern.strip.empty?
+            proc {
+              checks = begin
+                Flapjack::Data::Check.intersect(:name => Regexp.new(pattern.strip))
+              rescue RegexpError
+                nil
+              end
 
-          # hash with entity => check_list, filtered by pattern if required
-          entities = entity_names.map {|name|
-            Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
-          }.compact.inject({}) {|memo, entity|
-            memo[entity] = entity.check_list.select {|check_name|
-              !check_pattern || (check_name =~ /#{check_pattern}/i)
+              if checks.nil?
+                "Error parsing /#{pattern.strip}/"
+              else
+                num_checks = checks.count
+                if num_checks == 0
+                  "No checks match /#{pattern.strip}/"
+                else
+                  checks = checks.sort(:name, :limit => options[:limit]) if options[:limit]
+                  yield(checks.ids, "matching /#{pattern.strip}/", num_checks) if block_given?
+                end
+              end
             }
-            memo
-          }
+          elsif !tag_name.nil? && !tag_name.strip.empty?
+
+            lock_klasses.unshift(Flapjack::Data::Tag)
 
-          report_entities = proc {|ents|
-            ents.inject('') do |memo, (entity, check_list)|
-              if check_list.empty?
-                memo += "Entity: #{entity.name} has no checks\n"
+            proc {
+              tag = Flapjack::Data::Tag.intersect(:name => tag_name.strip).all.first
+
+              if tag.nil?
+                "No tag '#{tag_name.strip}'"
               else
-                memo += "Entity: #{entity.name}\nChecks: #{check_list.join(', ')}\n"
+                checks = tag.checks
+                num_checks = checks.count
+                if num_checks == 0
+                  "No checks with tag '#{tag_name.strip}'"
+                else
+                  checks = checks.sort(:name, :limit => options[:limit]) if options[:limit]
+                  yield(checks.ids, "with tag '#{tag_name}'", num_checks) if block_given?
+                end
               end
-              memo += "----\n"
-              memo
-            end
-          }
+            }
+          elsif !check_name.nil? && !check_name.strip.empty?
+            proc {
+              checks = Flapjack::Data::Check.intersect(:name => check_name.strip)
 
-          case
-          when entity_pattern
-            if entities.empty?
-              msg = "found no entities matching /#{entity_pattern}/"
-            else
-              msg = "found #{entities.size} entities matching /#{entity_pattern}/ ... \n" +
-                    report_entities.call(entities)
-            end
-          when entity_name
-            if entities.empty?
-              msg = "found no entity for '#{entity_name}'"
-            else
-              msg = report_entities.call(entities)
-            end
+              if checks.empty?
+                "No check exists with name '#{check_name.strip}'"
+              else
+                num_checks = checks.count
+                checks = checks.sort(:name, :limit => options[:limit]) if options[:limit]
+                yield(checks.ids, "with name '#{check_name.strip}'", num_checks) if block_given?
+              end
+            }
           end
 
-        when /^(?:find )?entities matching\s+\/(.+)\//im
-          pattern = $1.strip
-          entity_list = Flapjack::Data::Entity.find_all_name_matching(pattern, :redis => @redis)
-
-          if entity_list
-            max_showable = 30
-            number_found = entity_list.length
-            entity_list = entity_list[0..(max_showable - 1)] if number_found > max_showable
-
-            case
-            when number_found == 0
-              msg = "found no entities matching /#{pattern}/"
-            when number_found == 1
-              msg = "found 1 entity matching /#{pattern}/ ... \n"
-            when number_found > max_showable
-              msg = "showing first #{max_showable} of #{number_found} entities found matching /#{pattern}/\n"
-            else
-              msg = "found #{number_found} entities matching /#{pattern}/ ... \n"
-            end
-            msg += entity_list.join(', ') unless entity_list.empty?
+          return if deriver.nil?
 
+          if lock_klasses.empty?
+            Flapjack::Data::Check.lock(&deriver)
           else
-            msg = "that doesn't seem to be a valid pattern - /#{pattern}/"
+            Flapjack::Data::Check.lock(*lock_klasses, &deriver)
           end
+        end
 
-        when /^(?:ack )?entities\s+\/(.+)\/(?:\s*(.*?)(?:\s*duration:.*?(\w+.*))?)$/i
-          entity_pattern   = $1.strip
-          comment          = $2 ? $2.strip : nil
-          duration_str     = $3 ? $3.strip : '1 hour'
-          duration         = ChronicDuration.parse(duration_str)
-          entity_list      = Flapjack::Data::Entity.find_all_name_matching(entity_pattern, :redis => @redis)
+        def interpret(room, nick, time, command)
+          msg = nil
+          action = nil
+          check = nil
 
-          if comment.nil? || (comment.length == 0)
-            comment = "#{from}: Set via chatbot"
-          else
-            comment = "#{from}: #{comment}"
-          end
+          begin
+            case command
+            when /^help\s*$/
+              msg = "commands: \n" +
+                    "  find (number) checks matching /pattern/\n" +
+                    "  find (number) checks with tag <tag>\n" +
+                    "  state of <check>\n" +
+                    "  state of checks matching /pattern/\n" +
+                    "  state of checks with tag <tag>\n" +
+                    "  tell me about <check>\n" +
+                    "  tell me about (number) checks matching /pattern/\n" +
+                    "  tell me about (number) checks with tag <tag>\n" +
+                    "  ACKID <id>[ duration: <time spec>][ comment: <comment>]\n" +
+                    "  ack <check>[ duration: <time spec>][ comment: <comment>]\n" +
+                    "  ack checks matching /pattern/[ duration: <time spec>][ comment: <comment>]\n" +
+                    "  ack checks with tag <tag>[ duration: <time spec>][ comment: <comment>]\n" +
+                    "  maint <check>[ (start-at|start-in): <time spec>][ duration: <time spec>][ comment: <comment>]\n" +
+                    "  maint checks matching /pattern/[ (start-at|start-in): <time spec>][ duration: <time spec>][ comment: <comment>]\n" +
+                    "  maint checks with tag <tag>[ (start-at|start-in): <time spec>][ duration: <time spec>][ comment: <comment>]\n" +
+                    "  test notifications for <check>\n" +
+                    "  test notifications for checks matching /pattern/\n" +
+                    "  test notifications for checks with tag <tag>\n" +
+                    "  identify\n" +
+                    "  help\n"
+
+            when /^identify\s*$/
+              t    = Process.times
+              fqdn = `/bin/hostname -f`.chomp
+              pid  = Process.pid
+              msg  = "Flapjack #{Flapjack::VERSION} process #{pid} on #{fqdn} \n" +
+                     "Identifiers: #{@bot.identifiers.join(', ')}\n" +
+                     "Boot time: #{@boot_time}\n" +
+                     "User CPU Time: #{t.utime}\n" +
+                     "System CPU Time: #{t.stime}\n" +
+                     `uname -a`.chomp + "\n"
+
+            when /^find\s+(\d+\s+)?checks\s+(?:matching\s+\/(.+)\/|with\s+tag\s+(.+))\s*$/im
+              limit_checks = Regexp.last_match(1).nil? ? 30 : Regexp.last_match(1).strip.to_i
+              pattern     = Regexp.last_match(2)
+              tag         = Regexp.last_match(3)
+
+              msg = derive_check_ids_for(pattern, tag, nil, :limit => limit_checks) do |check_ids, descriptor, num_checks|
+                resp = "Checks #{descriptor}:\n"
+                checks = Flapjack::Data::Check.find_by_ids(*check_ids)
+                resp += "Showing first #{limit_checks} results of #{num_checks}:\n" if num_checks > limit_checks
+                resp += checks.map {|chk|
+                  cond = chk.condition
+                  "#{chk.name} is #{cond.nil? ? '[none]' : cond.upcase}"
+                }.join(', ')
+                resp
+              end
 
-          if entity_list
-            number_found = entity_list.length
-            case
-            when number_found == 0
-              msg = "found no entities matching /#{entity_pattern}/"
-            when number_found >= 1
-              failing_list = Flapjack::Data::EntityCheck.find_current_names_failing_by_entity(:redis => @redis)
-              entities = failing_list.select {|k,v| v.count >= 1 && entity_list.include?(k) }
-              if entities.length >= 1
-                entities.each_pair do |entity,check_list|
-                  check_list.each do |check|
-                    Flapjack::Data::Event.create_acknowledgement(
-                      entity, check,
-                      :summary => comment,
-                      :duration => duration,
-                      :redis => @redis
-                      )
-                  end
-                end
-                msg = entities.inject("Ack list:\n") {|memo,kv|
-                  kv[1].each {|e| memo << "#{kv[0]}:#{e}\n" }
-                  memo
-                }
-            else
-              msg = "found no matching entities with failing checks"
-            end
-          else
-            msg = "that doesn't seem to be a valid pattern - /#{pattern}/"
-          end
-        end
+            when /^state\s+of\s+#{CHECK_MATCH_FRAGMENT}\s*$/im
+              pattern    = Regexp.last_match(1)
+              tag        = Regexp.last_match(2)
+              check_name = Regexp.last_match(3)
+
+              msg = derive_check_ids_for(pattern, tag, check_name) do |check_ids, descriptor|
+                "State of checks #{descriptor}:\n" +
+                  Flapjack::Data::Check.intersect(:id => check_ids).collect {|chk|
+                    cond = chk.condition
+                    "#{chk.name} - #{cond.nil? ? '[none]' : cond.upcase}"
+                  }.join("\n")
+              end
 
-        when /^(?:maint )?entities\s+\/(.+)\/(?:\s*(.*?)(?:\s*start-in:.*?(\w+.*?))?(?:\s*start-at:.*?(\w+.*?))?(?:\s*duration:.*?(\w+.*?))?)$/i
-          entity_pattern   = $1.strip
-          comment          = $2 ? $2.strip : nil
-          start_in         = $3 ? $3.strip : nil
-          start_at         = $4 ? $4.strip : nil
-          duration_str     = $5 ? $5.strip : '1 hour'
-          maint_duration   = ChronicDuration.parse(duration_str)
-          entity_names     = Flapjack::Data::Entity.find_all_name_matching(entity_pattern, :redis => @redis)
-
-          if comment.nil? || (comment.length == 0)
-            comment = "#{from}: Set via chatbot"
-          else
-            comment = "#{from}: #{comment}"
-          end
+            when /^tell\s+me\s+about\s(\d+\s+)?+#{CHECK_MATCH_FRAGMENT}\s*$/im
+              limit_checks = Regexp.last_match(1).nil? ? 30 : Regexp.last_match(1).strip.to_i
+              pattern      = Regexp.last_match(2)
+              tag          = Regexp.last_match(3)
+              check_name   = Regexp.last_match(4)
+
+              msg = derive_check_ids_for(pattern, tag, check_name, :limit => limit_checks,
+                      :lock_klasses => [Flapjack::Data::ScheduledMaintenance,
+                                        Flapjack::Data::UnscheduledMaintenance]) do |check_ids, descriptor, num_checks|
+                current_time = Time.now
+                resp = "Details of checks #{descriptor}\n"
+                resp += "Showing first #{limit_checks} results of #{num_checks}:\n" if num_checks > limit_checks
+                resp += Flapjack::Data::Check.intersect(:id => check_ids).collect {|chk|
+                          get_check_details(chk, current_time)
+                        }.join("")
+              end
 
-          maint_start = case
-          when start_in
-            Time.now.to_i + ChronicDuration.parse(start_in)
-          when start_at
-            Chronic.parse(start_at).to_i
-          else
-            Time.now.to_i
-          end
+            when /^ACKID\s+([0-9A-F]+)(?:\s*(.*?)(?:\s*duration:.*?(\w+.*))?)$/im
+              ackid        = Regexp.last_match(1)
+              comment      = Regexp.last_match(2)
+              duration_str = Regexp.last_match(3)
 
-          if entity_names
-            number_found = entity_names.length
-            case
-            when number_found == 0
-              msg = "found no entities matching /#{entity_pattern}/"
-            when number_found >= 1
-              entities = entity_names.map {|name|
-                Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
-              }.compact.inject({}) {|memo, entity|
-                memo[entity] = entity.check_list.sort
-                memo
-              }
-              if entities.length >= 1
-                entities.each_pair do |entity,check_list|
-                  check_list.each do |check|
-                    entity_check = Flapjack::Data::EntityCheck.for_entity(entity, check, :redis => @redis)
-                    entity_check.create_scheduled_maintenance(
-                      maint_start,
-                      maint_duration,
-                      :summary => comment,
-                      )
-                    entity_check.update_current_scheduled_maintenance
-                  end
+              error = nil
+              dur   = nil
+
+              if comment.nil? || (comment.length == 0)
+                error = "please provide a comment, eg \"#{@bot.alias}: ACKID #{Regexp.last_match(1)} AL looking\""
+              elsif duration_str
+                # a fairly liberal match above, we'll let chronic_duration do the heavy lifting
+                dur = ChronicDuration.parse(duration_str)
+              end
+
+              four_hours = 4 * 60 * 60
+              duration = (dur.nil? || (dur <= 0)) ? four_hours : dur
+
+              check = Flapjack::Data::Check.intersect(:ack_hash => ackid).all.first
+
+              if check.nil?
+                msg = "ERROR - couldn't ACK #{ackid} - not found"
+              else
+                check_name = check.name
+
+                details = "#{check_name} (#{ackid})"
+                if check.in_unscheduled_maintenance?
+                  msg = "Changing ACK for #{details}"
+                else
+                  msg = "ACKing #{details}"
                 end
-                msg = entities.inject("Maint list:\n") {|memo,kv|
-                  kv[1].each {|e| memo << "#{kv[0].name}:#{e}\n" }
-                  memo
-                }
-            else
-              msg = "found no matching entities with active checks"
-            end
-          else
-            msg = "that doesn't seem to be a valid pattern - /#{pattern}/"
-          end
-        end
 
-        when /^(?:status )?entities\s+\/(.+)\/.*$/im
-          entity_pattern  = $1 ? $1.strip : nil
-          entity_names    = Flapjack::Data::Entity.find_all_name_matching(entity_pattern, :redis => @redis)
-
-          if entity_names
-            number_found = entity_names.length
-            case
-            when number_found == 0
-              msg = "found no entities matching /#{entity_pattern}/"
-            when number_found >= 1
-              entities = entity_names.map {|name|
-                Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
-              }.compact.inject({}) {|memo, entity|
-                memo[entity.name] = entity.check_list.map {|check_name|
-                  ec = Flapjack::Data::EntityCheck.for_entity(entity, check_name, :redis => @redis)
-                  "#{check_name}: #{ec.state}"
+                action = Proc.new {
+                  Flapjack::Data::Event.create_acknowledgements(
+                    @config['processor_queue'] || 'events',
+                    [check],
+                    :summary => (comment || ''),
+                    :acknowledgement_id => ackid,
+                    :duration => duration,
+                  )
                 }
-                memo
-              }
-              msg = entities.inject("Status list:\n") {|memo,kv|
-                kv[1].each {|e| memo << "#{kv[0]}:#{e}\n"}
-                memo
-              }
-            else
-              msg = "found no matching entities with failing checks"
-            end
-          else
-            msg = "that doesn't seem to be a valid pattern - /#{pattern}/"
-          end
+              end
 
-        when /^(?:ack )?checks\s+\/(.+)\/\s+on\s+\/(.+)\/(?:\s*(.*?)(?:\s*duration:.*?(\w+.*))?)$/i
-          check_pattern  = $1.strip
-          entity_pattern = $2.strip
-          comment        = $3 ? $3.strip : nil
-          duration_str   = $4 ? $4.strip : '1 hour'
-          duration       = ChronicDuration.parse(duration_str)
-          entity_list    = Flapjack::Data::Entity.find_all_name_matching(entity_pattern, :redis => @redis)
+            when /^ack\s+#{CHECK_MATCH_FRAGMENT}(?:\s+(.*?)(?:\s*duration:.*?(\w+.*))?)?\s*$/im
+              pattern      = Regexp.last_match(1)
+              tag          = Regexp.last_match(2)
+              check_name   = Regexp.last_match(3)
+              comment      = Regexp.last_match(4) ? Regexp.last_match(4).strip : nil
+              duration_str = Regexp.last_match(5) ? Regexp.last_match(5).strip : '1 hour'
+              duration     = ChronicDuration.parse(duration_str)
+
+              msg = derive_check_ids_for(pattern, tag, check_name,
+                      :lock_klasses => [Flapjack::Data::UnscheduledMaintenance]) do |check_ids, descriptor|
+
+                failing_checks = Flapjack::Data::Check.
+                  intersect(:id => check_ids, :failing => true)
+
+                if failing_checks.empty?
+                  "No failing checks #{descriptor}"
+                else
+                  summary = "#{nick}: #{comment.blank? ? 'Set via chatbot' : comment}"
+
+                  action = Proc.new {
+                    Flapjack::Data::Event.create_acknowledgements(
+                      @config['processor_queue'] || 'events',
+                      failing_checks,
+                      :summary  => summary,
+                      :duration => duration
+                    )
+                  }
+
+                  "Ack list:\n" + failing_checks.map(&:name).join("\n")
+                end
+              end
 
-          if comment.nil? || (comment.length == 0)
-            comment = "#{from}: Set via chatbot"
-          else
-            comment = "#{from}: #{comment}"
-          end
+            when /^maint\s+#{CHECK_MATCH_FRAGMENT}\s+(?:start-in:.*?(\w+.*?)|start-at:.*?(\w+.*?))?(?:\s+duration:.*?(\w+.*?))?(?:\s+comment:.*?(\w+.*?))?\s*$/im
+              pattern      = Regexp.last_match(1)
+              tag          = Regexp.last_match(2)
+              check_name   = Regexp.last_match(3)
+              start_in     = Regexp.last_match(4) ? Regexp.last_match(4).strip : nil
+              start_at     = Regexp.last_match(5) ? Regexp.last_match(5).strip : nil
+              duration_str = Regexp.last_match(6) ? Regexp.last_match(6).strip : '1 hour'
+              duration     = ChronicDuration.parse(duration_str)
+              comment      = Regexp.last_match(7) ? Regexp.last_match(7).strip : 'Test maintenance'
+
+              started = case
+              when start_in
+                Time.now.to_i + ChronicDuration.parse(start_in)
+              when start_at
+                Chronic.parse(start_at).to_i
+              else
+                Time.now.to_i
+              end
 
-          if entity_list
-            number_found = entity_list.length
-            case
-            when number_found == 0
-              msg = "found no entities matching /#{entity_pattern}/"
-            when number_found >= 1
+              msg = derive_check_ids_for(pattern, tag, check_name,
+                      :lock_klasses => [Flapjack::Data::ScheduledMaintenance]) do |check_ids, descriptor|
+                checks = Flapjack::Data::Check.find_by_ids(*check_ids)
 
-              failing_list = Flapjack::Data::EntityCheck.find_current_names_failing_by_entity(:redis => @redis)
+                checks.each do |chk|
+                  sched_maint = Flapjack::Data::ScheduledMaintenance.new(
+                    :start_time => started,
+                    :end_time   => started + duration,
+                    :summary    => comment
+                  )
+                  sched_maint.save
 
-              my_failing_checks = Hash[failing_list.map do |k,v|
-                if entity_list.include?(k)
-                  [k, v.keep_if {|e| e =~ /#{check_pattern}/}].compact
+                  chk.scheduled_maintenances << sched_maint
                 end
-              end]
-              if my_failing_checks.delete_if {|k,v| v.empty? }.length >= 1
-                my_failing_checks.each_pair do |entity,check_list|
-                  check_list.each do |check|
-                    Flapjack::Data::Event.create_acknowledgement(
-                      entity, check,
-                      :summary => comment,
-                      :duration => duration,
-                      :redis => @redis
-                      )
-                  end
-                end
-                msg = my_failing_checks.inject("Ack list:\n") {|memo,kv|
-                  kv[1].each {|e| memo << "#{kv[0]}:#{e}\n" }
-                  memo
+
+                "Scheduled maintenance for #{duration/60} minutes starting at #{Time.at(started)} on:\n" + checks.collect {|c| "#{c.name}" }.join("\n")
+              end
+
+            when /^test\s+notifications\s+for\s+#{CHECK_MATCH_FRAGMENT}\s*$/im
+              pattern    = Regexp.last_match(1)
+              tag        = Regexp.last_match(2)
+              check_name = Regexp.last_match(3)
+
+              msg = derive_check_ids_for(pattern, tag, check_name) do |check_ids, descriptor|
+                summary = "Testing notifications to all contacts interested in checks #{descriptor}"
+
+                checks = Flapjack::Data::Check.find_by_ids(*check_ids)
+
+                action = Proc.new {
+                  Flapjack::Data::Event.test_notifications(@config['processor_queue'] || 'events',
+                    checks, :summary => summary)
                 }
-            else
-              msg = "found no matching failing checks"
+                "Testing notifications for check#{(checks.size > 1) ? 's' : ''} #{descriptor}"
+              end
+
+            when /^(.*)/
+              words = Regexp.last_match(1)
+              msg   = "what do you mean, '#{words}'? Type 'help' for a list of acceptable commands."
+
             end
-          else
-            msg = "that doesn't seem to be a valid pattern - /#{pattern}/"
+
+          rescue => e
+            Flapjack.logger.error { "Exception when interpreting command '#{command}' - #{e.class}, #{e.message}" }
+            Flapjack.logger.debug { e.backtrace.join("\n") }
+            msg = "Oops, something went wrong processing that command (#{e.class}, #{e.message})"
           end
-        end
 
-        when /^(?:status )checks\s+\/(.+?)\/(?:\s+on\s+)?(?:\/(.+)?\/)?/i
-          check_pattern  = $1 ? $1.strip : nil
-          entity_pattern = $2 ? $2.strip : '.*'
-          entity_names   = Flapjack::Data::Entity.find_all_name_matching(entity_pattern, :redis => @redis)
-
-          if entity_names
-            number_found = entity_names.length
-            case
-            when number_found == 0
-              msg = "found no entities matching /#{entity_pattern}/"
-            when number_found >= 1
-              entities = entity_names.map {|name|
-                Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
-              }.compact.inject({}) {|memo, entity|
-                memo[entity.name] = entity.check_list.map {|check_name|
-                  if check_name =~ /#{check_pattern}/
-                    ec = Flapjack::Data::EntityCheck.for_entity(entity, check_name, :redis => @redis)
-                    "#{check_name}: #{ec.state}"
-                  end
-                }.compact
-                memo
-              }
-              if entities.delete_if {|k,v| v.empty? }.length >= 1
-                msg = entities.inject("Status list:\n") {|memo,kv|
-                  kv[1].each {|e| memo << "#{kv[0]}:#{e}\n" ; memo }
-                  memo
-                }
-              else
-                msg = "found no matching checks"
-              end
+          @bot ||= @siblings && @siblings.detect {|sib| sib.respond_to?(:announce) }
+
+          if @bot && (room || nick)
+            if room
+              Flapjack.logger.info "sending to room #{room}: #{msg}"
+              @bot.announce(room, msg)
             else
-              msg = "found no matching checks"
+              Flapjack.logger.info "sending to user #{nick}: #{msg}"
+              @bot.say(nick, msg)
             end
           else
-            msg = "that doesn't seem to be a valid pattern - /#{pattern}/"
+            Flapjack.logger.warn "jabber bot not running, won't send #{msg} to #{room || nick}"
           end
 
-        when /^(.*)/
-          words = $1
-          msg   = "what do you mean, '#{words}'? Type 'help' for a list of acceptable commands."
-
+          action.call if action
         end
 
-        {:msg => msg, :action => action}
       end
 
-      def on_groupchat(stanza)
-        return if @should_quit
-        @logger.debug("groupchat message received: #{stanza.inspect}")
+      class Bot
 
-        the_command = nil
-        @identifiers.each do |identifier|
-          if stanza.body =~ /^#{identifier}:?\s*(.*)/m
-            the_command  = $1
-            @logger.debug("matched identifier: #{identifier}, command: #{the_command.inspect}")
-            break
-          end
-        end
+        attr_accessor :siblings
+
+        def initialize(opts = {})
+          @lock = opts[:lock]
+          @stop_cond = opts[:stop_condition]
+          @config = opts[:config]
+          @boot_time = opts[:boot_time]
 
-        from = stanza.from
+          @say_buffer = []
+          @announce_buffer = []
+          @hostname = Socket.gethostname
 
-        begin
-          results = interpreter(the_command, from.to_s)
-          msg     = results[:msg]
-          action  = results[:action]
-        rescue => e
-          @logger.debug("Exception when interpreting command '#{the_command}' - #{e.class}, #{e.message}")
-          msg = "Oops, something went wrong processing that command (#{e.class}, #{e.message})"
+          @alias = @config['alias'] || 'flapjack'
+          @identifiers = ((@config['identifiers'] || []) + [@alias]).uniq
+
+          @state_buffer = []
+          @should_quit = false
         end
 
-        if msg || action
-          EventMachine::Synchrony.next_tick do
-            @logger.info("sending to group chat: #{msg}")
-            say(from.stripped, msg, :groupchat)
-            action.call if action
+        def alias
+          ret = nil
+          @lock.synchronize do
+            ret = @alias
           end
+          ret
         end
-      end
-
-      def on_chat(stanza)
-        return if @should_quit
-        @logger.debug("chat message received: #{stanza.inspect}")
 
-        if stanza.body =~ /^flapjack:\s+(.*)/m
-          command = $1
-        else
-          command = stanza.body
+        def identifiers
+          ret = nil
+          @lock.synchronize do
+            ret = @identifiers
+          end
+          ret
         end
 
-        from = stanza.from
+        def start
+          Flapjack.logger.debug("I will respond to the following identifiers: #{@identifiers.join(', ')}")
 
-        begin
-          results = interpreter(command, from.resource.to_s)
-          msg     = results[:msg]
-          action  = results[:action]
-        rescue => e
-          @logger.error("Exception when interpreting command '#{command}' - #{e.class}, #{e.message}")
-          msg = "Oops, something went wrong processing that command (#{e.class}, #{e.message})"
-        end
+          @lock.synchronize do
+            interpreter = self.siblings ? self.siblings.detect {|sib| sib.respond_to?(:interpret)} : nil
 
-        if msg || action
-          EventMachine::Synchrony.next_tick do
-            @logger.info("Sending to #{stanza.from.stripped}: #{msg}")
-            say(stanza.from.stripped, msg, :chat)
-            action.call if action
-          end
-        end
-      end
+            Flapjack.logger.info("starting")
+            Flapjack.logger.debug("new jabber pikelet with the following options: #{@config.inspect}")
 
-      def connect_with_retry
-        attempt = 0
-        delay = 2
-        begin
-          attempt += 1
-          delay = 10 if attempt > 10
-          delay = 60 if attempt > 60
-          EventMachine::Synchrony.sleep(delay || 3) if attempt > 1
-          @logger.debug("attempting connection to the jabber server")
-          connect # Blather::Client.connect
-        rescue StandardError => detail
-          @logger.error("unable to connect to the jabber server (attempt #{attempt}), retrying in #{delay} seconds ...")
-          @logger.error("detail: #{detail.message}")
-          @logger.debug(detail.backtrace.join("\n"))
-          retry unless @should_quit
-        end
-      end
+            # ::Jabber::debug = true
 
-      # returning true to prevent the reactor loop from stopping
-      def on_disconnect(stanza)
-        @logger.warn("disconnect handler called")
-        return true if @should_quit
-        @logger.warn("jabbers disconnected! reconnecting after a short deley ...")
-        EventMachine::Synchrony.sleep(5)
-        connect_with_retry
-        true
-      end
+            jabber_id = @config['jabberid'] || 'flapjack'
+            jabber_id += '/' + @hostname unless jabber_id.include?('/')
+            flapjack_jid = ::Jabber::JID.new(jabber_id)
+            client = ::Jabber::Client.new(flapjack_jid)
 
-      def say(to, msg, using = :chat, tick = true)
-        stanza = Blather::Stanza::Message.new(to, msg, using)
-        if connected?
-          @logger.debug("Sending a jabber message to: #{to.to_s}, using: #{using.to_s}, message: #{msg}")
-          write(stanza)
-        else
-          @logger.debug("Buffering a jabber message to: #{to.to_s}, using: #{using.to_s}, message: #{msg}")
-          @buffer << stanza
-        end
-      end
+            client.on_exception do |exc, stream, loc|
+              leave_and_rejoin = nil
+
+              @lock.synchronize do
+
+                # called with a nil exception on disconnect for some reason
+                if exc
+                  Flapjack.logger.error exc.class.name
+                  Flapjack.logger.error ":#{loc.to_s}"
+                  Flapjack.logger.error exc.message
+                  Flapjack.logger.error exc.backtrace.join("\n")
+                end
 
-      def start
-        @logger.info("starting")
-        @logger.debug("new jabber pikelet with the following options: #{@config.inspect}")
-
-        # the periodic timer can't be halted early (without doing EM.stop) so
-        # keep the time short and count the iterations ... could just use
-        # EM.sleep(1) in a loop, I suppose
-        ki = 0
-        keepalive_timer = EventMachine::Synchrony.add_periodic_timer(1) do
-          ki += 1
-          if ki == 60
-            ki = 0
-            @logger.debug("calling keepalive on the jabber connection")
-            if connected?
-              EventMachine::Synchrony.next_tick do
-                write(' ')
+                leave_and_rejoin = @joined && !@should_quit
+
+                if leave_and_rejoin
+                  @state_buffer << 'leave'
+                  @stop_cond.signal
+                end
               end
-            end
-          end
-        end
 
-        setup
-        connect_with_retry
+              if leave_and_rejoin
+                sleep 3
+                @lock.synchronize do
+                  unless @should_quit
+                    @state_buffer << 'rejoin'
+                    @stop_cond.signal
+                  end
+                end
+              end
+            end
 
-        # simplified to use a single queue only as it makes the shutdown logic easier
-        queue = @config['queue']
-        events = {}
+            check_xml = Proc.new do |data|
+              if data.nil?
+                nil
+              else
+                Flapjack.logger.debug "xml_data: #{data}"
+                text = ''
+                begin
+                  enc_name = Encoding.default_external.name
+                  REXML::Document.new("<?xml version=\"1.0\" encoding=\"#{enc_name}\"?>" + data).
+                    each_element_with_text do |elem|
+
+                    text += elem.texts.join(" ")
+                  end
+                  text = data if text.empty? && !data.empty?
+                rescue REXML::ParseException
+                  # invalid XML, so we'll just clear everything inside angled brackets
+                  text = data.gsub(/<[^>]+>/, '').strip
+                end
+                text
+              end
+            end
 
-        until @should_quit
+            client.add_message_callback do |m|
+              unless (m.type != :chat) || m.body.nil? || m.body.strip.empty?
+                Flapjack.logger.debug "received message #{m.inspect}"
+                nick = m.from
+                time = nil
+                m.each_element('x') { |x|
+                  if x.kind_of?(::Jabber::Delay::XDelay)
+                    time = x.stamp
+                  end
+                }
 
-          # FIXME: should also check if presence has been established in any group chat rooms that are
-          # configured before starting to process events, otherwise the first few may get lost (send
-          # before joining the group chat rooms)
-          unless connected?
-            @logger.debug("not connected, sleep 1 before retry")
-            EM::Synchrony.sleep(1)
-            next
-          end
+                unless interpreter.nil?
+                  interpreter.receive_message(nil, nick, time, check_xml.call(m.body))
+                end
+              end
+            end
 
-          @logger.debug("jabber is connected so commencing blpop on #{queue}")
-          events[queue] = @redis.blpop(queue, 0)
-          event_json = events[queue][1]
-          begin
-            event = Flapjack.load_json(event_json)
+            muc_clients = @config['rooms'].inject({}) do |memo, room|
+              muc_client = ::Jabber::MUC::SimpleMUCClient.new(client)
+              muc_client.on_message do |time, nick, text|
+                Flapjack.logger.debug("message #{text} -- #{time} -- #{nick}")
+                next if nick == jabber_id
+                identifier = identifiers.detect {|id| /^(?:@#{id}|#{id}:)\s*(.*)/m === check_xml.call(text) }
+
+                unless identifier.nil?
+                  the_command = Regexp.last_match(1)
+                  Flapjack.logger.debug("matched identifier: #{identifier}, command: #{the_command.inspect}")
+                  if interpreter
+                    interpreter.receive_message(room, nick, time, the_command)
+                  end
+                end
+              end
 
-            @logger.debug('jabber notification event received: ' + event.inspect)
+              memo[room] = muc_client
+              memo
+            end
 
-            if 'shutdown'.eql?(event['notification_type'])
-              @logger.debug("@should_quit: #{@should_quit}")
-              if @should_quit
-                EventMachine::Synchrony.next_tick do
-                  # get delays without the next_tick
-                  close # Blather::Client.close
+            attempts_allowed = 3
+            attempts_remaining = attempts_allowed
+            @joined = false
+
+            loop do
+
+              if @joined
+                # block this thread until signalled to quit / leave / rejoin
+                @stop_cond.wait_until { @should_quit || !@state_buffer.empty? }
+              elsif attempts_remaining > 0
+                unless @should_quit || (attempts_remaining == attempts_allowed)
+                  # The only thing that should be interrupting this wait is
+                  # a pikelet.stop, which would set @should_quit to true;
+                  # thus we shouldn't see multiple connection attempts happening
+                  # too quickly.
+                  @stop_cond.wait(3)
                 end
+                unless @should_quit # may have changed during previous wait
+                  begin
+                    attempts_remaining -= 1
+                    _join(client, muc_clients)
+                    @joined = true
+                  rescue Errno::ECONNREFUSED, ::Jabber::JabberError => je
+                    report_error("Couldn't join Jabber server #{@hostname}", je)
+                  end
+                end
+              else
+                # TODO should we quit Flapjack entirely?
+                Flapjack.logger.error "stopping jabber bot, couldn't connect in #{attempts_allowed} attempts"
+                @should_quit = true
               end
-              next
+
+              break if @should_quit
+              handle_state_change(client, muc_clients) unless @state_buffer.empty?
             end
 
-            alert = Flapjack::Data::Alert.new(event, :logger => @logger)
+            # main loop has finished, stop() must have been called -- disconnect
+            _leave(client, muc_clients) if client.is_connected?
+          end
+        end
+
+        def announce(room, msg)
+          @lock.synchronize do
+            @announce_buffer += [{:room => room, :msg => msg}]
+            @state_buffer << 'announce'
+            @stop_cond.signal
+          end
+        end
 
-            @logger.debug("processing jabber notification address: #{alert.address}, entity: #{alert.entity}, " +
-                          "check: '#{alert.check}', state: #{alert.state}, summary: #{alert.summary}")
+        def say(nick, msg)
+          @lock.synchronize do
+            @say_buffer += [{:nick => nick, :msg => msg}]
+            @state_buffer << 'say'
+            @stop_cond.signal
+          end
+        end
 
-            @ack_str = if alert.state.eql?('ok') || ['test', 'acknowledgement'].include?(alert.type)
-              nil
+        def handle_state_change(client, muc_clients)
+          connected = client.is_connected?
+          Flapjack.logger.debug "connected? #{connected}"
+
+          while state = @state_buffer.pop
+            Flapjack.logger.debug "state change #{state}"
+            case state
+            when 'announce'
+              _announce(muc_clients) if connected
+            when 'say'
+              _say(client) if connected
+            when 'leave'
+              connected ? _leave(client, muc_clients) : _deactivate(muc_clients)
+            when 'rejoin'
+              _join(client, muc_clients, :rejoin => true) unless connected
             else
-              "#{@config['alias']}: ACKID #{alert.event_hash}"
+              Flapjack.logger.warn "unknown state change #{state}"
             end
+          end
+        end
 
-            message_type = alert.rollup ? 'rollup' : 'alert'
+        def stop_type
+          :signal
+        end
 
-            message_template_erb, message_template =
-              load_template(@config['templates'], message_type,
-                            'text', File.join(File.dirname(__FILE__), 'jabber'))
+        def report_error(error_msg, je)
+          Flapjack.logger.error error_msg
+          message = je.respond_to?(:message) ? je.message : '-'
+          Flapjack.logger.error "#{je.class.name} #{message}"
+          # if je.respond_to?(:backtrace) && trace = je.backtrace
+          #   Flapjack.logger.error trace.join("\n")
+          # end
+        end
 
-            @alert = alert
-            bnd    = binding
+        def _join(client, muc_clients, opts = {})
+          client.connect
+          client.auth(@config['password'])
+          client.send(::Jabber::Presence.new)
+          muc_clients.each_pair do |room, muc_client|
+            attempts_allowed = 3
+            attempts_remaining = attempts_allowed
+            joined = nil
+            while !joined && (attempts_remaining > 0)
+              @lock.synchronize do
+                unless @should_quit || (attempts_remaining == attempts_allowed)
+                  # The only thing that should be interrupting this wait is
+                  # a pikelet.stop, which would set @should_quit to true;
+                  # thus we shouldn't see multiple connection attempts happening
+                  # too quickly.
+                  @stop_cond.wait(3)
+                end
+              end
 
-            begin
-              message = message_template_erb.result(bnd).chomp
-            rescue => e
-              @logger.error "Error while executing the ERB for a jabber message, " +
-                "ERB being executed: #{message_template}"
-              raise
+              # may have changed during previous wait
+              sq = nil
+              @lock.synchronize do
+                sq = @should_quit
+              end
+
+              unless sq
+                attempts_remaining -= 1
+                begin
+                  muc_client.join(room + '/' + @alias, nil, :history => false)
+                  t = Time.now
+                  msg = opts[:rejoin] ? "flapjack jabber gateway rejoining at #{t}, hello again!" :
+                                        "flapjack jabber gateway started at #{t}, hello! Try typing 'help'."
+                  muc_client.say(msg) if @config['chatbot_announce']
+                  joined = true
+                rescue Errno::ECONNREFUSED, ::Jabber::JabberError => muc_je
+                  report_error("Couldn't join MUC room #{room}, #{attempts_remaining} attempts remaining", muc_je)
+                  raise if attempts_remaining <= 0
+                  joined = false
+                end
+              end
             end
+          end
+        end
+
+        def _leave(client, muc_clients)
+          if @joined
+            muc_clients.values.each {|muc_client| muc_client.exit if muc_client.active? }
+            client.close
+          end
+          @joined = false
+        end
+
+        def _deactivate(muc_clients)
+          # send method has been overridden in MUCClient class
+          # without this MUC clients will still think they are active
+          muc_clients.values.each {|muc_client| muc_client.__send__(:deactivate) }
+        end
 
-            chat_type = :chat
-            chat_type = :groupchat if @config['rooms'] && @config['rooms'].include?(alert.address)
-            EventMachine::Synchrony.next_tick do
-              say(Blather::JID.new(alert.address), message, chat_type)
-              alert.record_send_success!
+        def _announce(muc_clients)
+          @announce_buffer.each do |announce|
+            if (muc_client = muc_clients[announce[:room]]) && muc_client.active?
+              muc_client.say(announce[:msg])
+              announce[:sent] = true
             end
+          end
+          @announce_buffer.delete_if {|announce| announce[:sent] }
+        end
 
-          rescue => e
-            # TODO: have non-fatal errors generate messages (eg via flapjack events or straight to
-            # rollbar or similar)
-            @logger.error "Error generating or dispatching jabber message: #{e.class}: #{e.message}\n" +
-              e.backtrace.join("\n")
-            @logger.debug "Message that could not be processed: \n" + event_json
+        def _say(client)
+          while speak = @say_buffer.pop
+            msg = ::Jabber::Message::new(speak[:nick], speak[:msg])
+            msg.type = :chat
+            client.send( msg )
           end
         end
 
-        keepalive_timer.cancel
       end
 
     end
-
   end
 end