flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/gateways/jsonapi/{rack → middleware}/json_params_parser.rb

@@ -5,23 +5,24 @@ require 'rack'
 module Flapjack
   module Gateways
     class JSONAPI < Sinatra::Base
-      module Rack
+      module Middleware
         class JsonParamsParser < Struct.new(:app)
           def call(env)
             t = type(env)
-            if env['rack.input'] && !input_parsed?(env) && type_match?(t)
+            if ['POST', 'PATCH', 'DELETE'].include?(env["REQUEST_METHOD"]) &&
+              env['rack.input'] && !input_parsed?(env) && type_match?(t)
+
               env['rack.request.form_input'] = env['rack.input']
               json_data = env['rack.input'].read
               env['rack.input'].rewind
               data = json_data.empty? ? {} : Flapjack.load_json(json_data)
-              env['rack.request.form_hash'] = data.empty? ? {} :
-                (('application/json-patch+json'.eql?(t)) ? {'ops' => data} : data)
+              env['rack.request.form_hash'] = data
             end
             app.call(env)
           end
 
           def input_parsed? env
-            env['rack.request.form_input'].eql? env['rack.input']
+            env['rack.request.form_input'].eql?(env['rack.input'])
           end
 
           def type(env)
@@ -30,7 +31,7 @@ module Flapjack
           end
 
           def type_match?(t)
-            Flapjack::Gateways::JSONAPI::JSON_REQUEST_MIME_TYPES.include?(t)
+            Flapjack::Gateways::JSONAPI::JSONAPI_MEDIA_TYPE.eql?(t)
           end
         end
       end

data/lib/flapjack/gateways/jsonapi/middleware/request_timestamp.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'rack'
+
+module Flapjack
+  module Gateways
+    class JSONAPI < Sinatra::Base
+      module Middleware
+        class RequestTimestamp < Struct.new(:app)
+          def call(env)
+            env['request_timestamp'] = Time.now
+            app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/gateways/oobetet.rb

@@ -1,240 +1,292 @@
 #!/usr/bin/env ruby
 
+require 'net/http'
 require 'socket'
-require 'eventmachine'
-require 'em-synchrony'
-require 'blather/client/client'
+require 'uri'
+require 'uri/https'
 
+require 'xmpp4r'
+require 'xmpp4r/muc/helper/simplemucclient'
+
+require 'flapjack/exceptions'
 require 'flapjack/utility'
 
 module Flapjack
 
   module Gateways
 
-    class Oobetet < Blather::Client
-      include Flapjack::Utility
+    module Oobetet
 
-      log = ::Logger.new(STDOUT)
-      log.level = ::Logger::INFO
-      Blather.logger = log
+      class Notifier
 
-      def initialize(opts = {})
-        @config = opts[:config]
-        @logger = opts[:logger]
-        super()
-      end
+        attr_accessor :siblings
 
-      def stop
-        @should_quit = true
-      end
+        def initialize(options = {})
+          @lock = options[:lock]
+          @config = options[:config]
 
-      def setup
-        @hostname = Socket.gethostname
-        @flapjacktest_jid = Blather::JID.new((@config['jabberid'] || 'flapjacktest') + "/#{@hostname}:#{Process.pid}")
+          @hostname = Socket.gethostname
 
-        super(@flapjacktest_jid, @config['password'], @config['server'], @config['port'].to_i)
+          unless @config['watched_check']
+            raise RuntimeError, 'Flapjack::Oobetet: watched_check must be defined in the config'
+          end
+          @check_matcher = '"' + @config['watched_check'] + '"'
 
-        @logger.debug("Building jabber connection with jabberid: " +
-          @flapjacktest_jid.to_s + ", port: " + @config['port'].to_s +
-          ", server: " + @config['server'].to_s + ", password: " +
-          @config['password'].to_s)
+          @flapjack_ok = true
+          @last_alert = nil
+          @last_breach = nil
+        end
 
-        @pagerduty_events_api_url = 'https://events.pagerduty.com/generic/2010-04-15/create_event.json'
+        def start
+          loop do
+            @lock.synchronize do
+              check_timers
+            end
 
-        if !@config['watched_check'] or !@config['watched_entity']
-          raise RuntimeError, 'Flapjack::Oobetet: watched_check and watched_entity must be defined in the config'
+            Kernel.sleep 10
+          end
         end
 
-        @check_matcher = '"' + @config['watched_check'] + '" on ' + @config['watched_entity']
-        @max_latency = @config['max_latency'] || 300
-        @flapjack_ok = true
-
-        t = Time.now.to_i
-        @times = { :last_problem  => t,
-                   :last_recovery => t,
-                   :last_ack      => t,
-                   :last_ack_sent => t }
+        def stop_type
+          :exception
+        end
 
-        @last_alert = nil
-      end
+        private
 
-      # split out to ease testing
-      def register_handlers
-        register_handler :ready do |stanza|
-          EventMachine::Synchrony.next_tick do
-            on_ready(stanza)
+        def check_timers
+          if @siblings
+            @time_checker ||= @siblings.detect {|sib| sib.respond_to?(:breach?) }
+            @bot ||= @siblings.detect {|sib| sib.respond_to?(:announce) }
           end
-        end
 
-        register_handler :message, :groupchat? do |stanza|
-          EventMachine::Synchrony.next_tick do
-            on_groupchat(stanza)
+          t = Time.now
+          breach = @time_checker.breach?(t) if @time_checker
+
+          if @last_breach && !breach
+            emit_jabber("Flapjack Self Monitoring is OK")
+            emit_pagerduty("Flapjack Self Monitoring is OK", 'resolve')
           end
-        end
 
-        register_handler :disconnected do |stanza|
-          ret = true
-          EventMachine::Synchrony.next_tick do
-            ret = on_disconnect(stanza)
+          @last_breach = breach
+          return unless breach
+
+          Flapjack.logger.error("Self monitoring has detected the following breach: #{breach}")
+          summary = "Flapjack Self Monitoring is Critical: #{breach} for #{@check_matcher}, " +
+                    "from #{@hostname} at #{t}"
+
+          if @last_alert.nil? || @last_alert < (t.to_i - 55)
+
+            announced_jabber    = emit_jabber(summary)
+            announced_pagerduty = emit_pagerduty(summary, 'trigger')
+
+            @last_alert = t.to_i if announced_jabber || announced_pagerduty
+
+            if @last_alert.nil? || @last_alert < (t.to_i - 55)
+              msg = "NOTICE: Self monitoring has detected a failure and is unable to tell " +
+                    "anyone about it. DON'T PANIC."
+              Flapjack.logger.error msg
+            end
           end
-          ret
         end
-      end
 
+        def emit_jabber(summary)
+          return if @bot.nil?
+          @bot.announce(summary)
+          true
+        end
 
-      # 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 = @flapjacktest_jid
-            presence.to = Blather::JID.new("#{room}/#{@config['alias']}")
-            presence << "<x xmlns='http://jabber.org/protocol/muc'/>"
-            write presence
-            say(room, "flapjack self monitoring (oobetet) started at #{Time.now}, g'day!", :groupchat)
+        def emit_pagerduty(summary, event_type = 'trigger')
+          return if @config['pagerduty_contact'].nil?
+          status, response = send_pagerduty_event(:service_key  => @config['pagerduty_contact'],
+                                                  :incident_key => "Flapjack Self Monitoring from #{@hostname}",
+                                                  :event_type   => event_type,
+                                                  :description  => summary)
+          unless '200'.eql?(status)
+            Flapjack.logger.error("pagerduty returned #{status} #{response.inspect}")
+            return false
           end
+
+          Flapjack.logger.debug("successfully sent pagerduty event")
+          true
         end
-      end
 
-      # returning true to prevent the reactor loop from stopping
-      def on_disconnect(stanza)
-        return true if @should_quit
-        @logger.warn("jabbers disconnected! reconnecting in 1 second ...")
-        EventMachine::Timer.new(1) do
-          connect # Blather::Client.connect
+        # TODO trap Oj JSON errors
+        # FIXME common code with the pagerduty gateway, move to shared module
+        def send_pagerduty_event(opts = {})
+          event = { 'service_key'  => opts[:service_key],
+                    'incident_key' => opts[:incident_key],
+                    'event_type'   => opts[:event_type],
+                    'description'  => opts[:description] }
+
+          uri = URI::HTTPS.build(:host => 'events.pagerduty.com',
+                                 :path => '/generic/2010-04-15/create_event.json',
+                                 :port => 443)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          request = Net::HTTP::Post.new(uri.request_uri)
+          request.body = Flapjack.dump_json(event)
+          http_response = http.request(request)
+
+          response = Flapjack.load_json(http_response.body)
+          status   = http_response.code
+          Flapjack.logger.debug "send_pagerduty_event got a return code of #{status} - #{response.inspect}"
+          [status, response]
         end
-        true
+
       end
 
-      def on_groupchat(stanza)
-        return if @should_quit
+      class TimeChecker
 
-        stanza_body = stanza.body
+        def initialize(opts = {})
+          @lock   = opts[:lock]
+          @stop_cond = opts[:stop_condition]
+          @config = opts[:config]
 
-        @logger.debug("groupchat stanza body: #{stanza_body}")
-        @logger.debug("groupchat message received: #{stanza.inspect}")
+          @max_latency = @config['max_latency'] || 300
 
-        if (stanza_body =~ /^(?:problem|recovery|acknowledgement)/i) &&
-           (stanza_body =~ /^(\w+).*#{Regexp.escape(@check_matcher)}/)
+          @times = { :last_problem  => nil,
+                     :last_recovery => nil,
+                     :last_ack      => nil,
+                     :last_ack_sent => nil }
 
-          # got something interesting
-          status = $1.downcase
-          t = Time.now.to_i
-          @logger.debug("groupchat found the following state for #{@check_matcher}: #{status}")
+          Flapjack.logger.debug("new oobetet pikelet with the following options: #{@config.inspect}")
+        end
 
-          case status
-          when 'problem'
-            @logger.debug("updating @times last_problem")
-            @times[:last_problem] = t
-          when 'recovery'
-            @logger.debug("updating @times last_recovery")
+        def start
+          @lock.synchronize do
+            t = Time.now.to_i
+            @times[:last_problem]  = t
             @times[:last_recovery] = t
-          when 'acknowledgement'
-            @logger.debug("updating @times last_ack")
-            @times[:last_ack] = t
+            @times[:last_ack]      = t
+            @times[:last_ack_sent] = t
+            @stop_cond.wait_until { @should_quit }
           end
         end
-        @logger.debug("@times: #{@times.inspect}")
-      end
 
-      def check_timers
-        t = Time.now.to_i
-        breach = nil
-        @logger.debug("check_timers: inspecting @times #{@times.inspect}")
-        case
-        when @times[:last_problem] < (t - @max_latency)
-          breach = "haven't seen a test problem notification in the last #{@max_latency} seconds"
-        when @times[:last_recovery] < (t - @max_latency)
-          breach = "haven't seen a test recovery notification in the last #{@max_latency} seconds"
+        def stop_type
+          :signal
+        end
+
+        def receive_status(status, time)
+          @lock.synchronize do
+            case status
+            when 'problem'
+              Flapjack.logger.debug("updating @times last_problem")
+              @times[:last_problem] = time
+            when 'recovery'
+              Flapjack.logger.debug("updating @times last_recovery")
+              @times[:last_recovery] = time
+            when 'acknowledgement'
+              Flapjack.logger.debug("updating @times last_ack")
+              @times[:last_ack] = time
+            end
+            Flapjack.logger.debug("@times: #{@times.inspect}")
+          end
         end
 
-        unless @flapjack_ok || breach
-          emit_jabber("Flapjack Self Monitoring is OK")
-          emit_pagerduty("Flapjack Self Monitoring is OK", 'resolve')
+        def breach?(time)
+          @lock.synchronize do
+            Flapjack.logger.debug("check_timers: inspecting @times #{@times.inspect}")
+            if @times[:last_problem] < (time - @max_latency)
+              "haven't seen a test problem notification in the last #{@max_latency} seconds"
+            elsif @times[:last_recovery] < (time - @max_latency)
+              "haven't seen a test recovery notification in the last #{@max_latency} seconds"
+            end
+          end
         end
 
-        @flapjack_ok = !breach
+      end
 
-        return unless breach
-        @logger.error("Self monitoring has detected the following breach: #{breach}")
-        summary  = "Flapjack Self Monitoring is Critical: #{breach} for #{@check_matcher}, "
-        summary += "from #{@hostname} at #{Time.now}"
+      class Bot
 
-        if !@last_alert or @last_alert < (t - 55)
+        include Flapjack::Utility
 
-          emit_jabber(summary)
-          emit_pagerduty(summary, 'trigger')
+        attr_accessor :siblings
 
-          if !@last_alert or @last_alert < (t - 55)
-            msg  = "NOTICE: Self monitoring has detected a failure and is unable to tell "
-            msg += "anyone about it. DON'T PANIC."
-            @logger.error msg
-          end
+        def initialize(opts = {})
+          @lock = opts[:lock]
+          @stop_cond = opts[:stop_condition]
+          @config = opts[:config]
 
-        end
-      end
+          @hostname = Socket.gethostname
 
-      def emit_jabber(summary)
-        if @config['rooms'] && @config['rooms'].length > 0
-          @config['rooms'].each do |room|
-            say(room, summary, :groupchat)
+          unless @config['watched_check']
+            raise RuntimeError, 'Flapjack::Oobetet: watched_check must be defined in the config'
           end
-          @last_alert = Time.now.to_i
-        end
-      end
+          @check_matcher = '"' + @config['watched_check'] + '"'
 
-      def emit_pagerduty(summary, event_type = 'trigger')
-        if @config['pagerduty_contact']
-          pagerduty_event = { 'service_key'  => @config['pagerduty_contact'],
-                              'incident_key' => "Flapjack Self Monitoring from #{@hostname}",
-                              'event_type'   => event_type,
-                              'description'  => summary }
-          status, response = send_pagerduty_event(pagerduty_event)
-          if status == 200
-            @logger.debug("successfully sent pagerduty event")
-            @last_alert = Time.now.to_i
-          else
-            @logger.error("pagerduty returned #{status} #{response.inspect}")
-          end
+          Flapjack.logger.debug("new oobetet pikelet with the following options: #{@config.inspect}")
         end
-      end
 
-      def say(to, msg, using = :chat)
-        @logger.debug("Sending a jabber message to: #{to.to_s}, using: #{using.to_s}, message: #{msg}")
-        write Blather::Stanza::Message.new(to, msg, using)
-      end
+        def start
+          @lock.synchronize do
+            @time_checker ||= @siblings && @siblings.detect {|sib| sib.respond_to?(:receive_status) }
 
-      def send_pagerduty_event(event)
-        options  = { :body => Flapjack.dump_json(event) }
-        http     = EM::HttpRequest.new(@pagerduty_events_api_url).post(options)
-        response = Flapjack.load_json(http.response)
-        status   = http.response_header.status
-        @logger.debug "send_pagerduty_event got a return code of #{status.to_s} - #{response.inspect}"
-        [status, response]
-      end
+            Flapjack.logger.info("starting")
 
-      def start
-        @logger.debug("New oobetet pikelet with the following options: #{@config.inspect}")
+            # ::Jabber::debug = true
 
-        keepalive_timer = EM::Synchrony.add_periodic_timer(60) do
-          @logger.debug("calling keepalive on the jabber connection")
-          write(' ') if connected?
+            jabber_id = @config['jabberid'] || 'flapjack'
+
+            @flapjack_jid = ::Jabber::JID.new(jabber_id + '/' + @hostname)
+            @client = ::Jabber::Client.new(@flapjack_jid)
+
+            @muc_clients = @config['rooms'].inject({}) do |memo, room|
+              muc_client = ::Jabber::MUC::SimpleMUCClient.new(@client)
+              memo[room] = muc_client
+              memo
+            end
+
+            @client.connect
+            @client.auth(@config['password'])
+            @client.send(::Jabber::Presence.new.set_type(:available))
+
+            @muc_clients.each_pair do |room, muc_client|
+              muc_client.on_message do |time, nick, text|
+                next if nick == jabber_id
+
+                if @time_checker
+                  Flapjack.logger.debug("group message received: #{room}, #{text}")
+                  if (text =~ /^((?i:problem|recovery|acknowledgement)).*#{Regexp.escape(@check_matcher)}/)
+                    # got something interesting
+                    status = Regexp.last_match(1).downcase
+                    Flapjack.logger.debug("found the following state for #{@check_matcher}: #{status}")
+                    @time_checker.receive_status(status, time.to_i)
+                  end
+                end
+              end
+
+              muc_client.join(room + '/' + @config['alias'])
+              muc_client.say("flapjack oobetet gateway started at #{Time.now}, hello!")
+            end
+
+            # block this thread until signalled to quit
+            @stop_cond.wait_until { @should_quit }
+
+            @muc_clients.each_pair do |room, muc_client|
+              muc_client.exit if muc_client.active?
+            end
+
+            @client.close
+          end
         end
 
-        setup
-        register_handlers
-        connect # Blather::Client.connect
+        def stop_type
+          :signal
+        end
 
-        until @should_quit
-          EM::Synchrony.sleep(10)
-          check_timers
+        # TODO buffer if not connected?
+        def announce(msg)
+          @lock.synchronize do
+            unless @muc_clients.empty?
+              @muc_clients.each_pair do |room, muc_client|
+                muc_client.say(msg)
+              end
+            end
+          end
         end
 
-        keepalive_timer.cancel
       end
 
     end