flapjack-diner 1.0.0 → 1.2.0

data/lib/flapjack-diner/resources/notification_rules.rb

@@ -0,0 +1,66 @@
+require 'httparty'
+require 'json'
+require 'uri'
+
+require 'flapjack-diner/version'
+require 'flapjack-diner/argument_validator'
+
+module Flapjack
+  module Diner
+    module Resources
+      module NotificationRules
+        def create_contact_notification_rules(*args)
+          ids, data = unwrap_ids(*args), unwrap_create_data(*args)
+          raise "'create_contact_notification_rules' requires at least one " \
+                'contact id parameter' if ids.nil? || ids.empty?
+          validate_params(data) do
+            validate :query => STRING_PARAMS,  :as => :array_of_strings
+            validate :query => BOOLEAN_PARAMS, :as => :boolean
+          end
+          perform_post("/contacts/#{escaped_ids(ids)}/notification_rules",
+                       nil, :notification_rules => data)
+        end
+
+        def notification_rules(*ids)
+          perform_get('notification_rules', '/notification_rules', ids)
+        end
+
+        def update_notification_rules(*args)
+          ids, params = unwrap_ids(*args), unwrap_params(*args)
+          raise "'update_notification_rules' requires at least one " \
+                'notification rule id parameter' if ids.nil? || ids.empty?
+          validate_params(params) do
+            validate :query => STRING_PARAMS,  :as => :array_of_strings
+            validate :query => BOOLEAN_PARAMS, :as => :boolean
+          end
+          perform_patch("/notification_rules/#{escaped_ids(ids)}", nil,
+                        update_notification_rules_ops(params))
+        end
+
+        def delete_notification_rules(*ids)
+          raise "'delete_notification_rules' requires at least one " \
+                'notification rule id parameter' if ids.nil? || ids.empty?
+          perform_delete('/notification_rules', ids)
+        end
+
+        private
+
+        STRING_PARAMS  = [:entities, :regex_entities, :tags, :regex_tags,
+                          :unknown_media, :warning_media, :critical_media]
+        BOOLEAN_PARAMS = [:unknown_blackhole, :warning_blackhole,
+                          :critical_blackhole]
+        OTHER_PARAMS   = [:time_restrictions]
+
+        def update_notification_rules_ops(params)
+          ops = params.each_with_object([]) do |(k, v), memo|
+            next unless (STRING_PARAMS + BOOLEAN_PARAMS + OTHER_PARAMS).include?(k)
+            memo << patch_replace('notification_rules', k, v)
+          end
+          raise "'update_notification_rules' did not find any valid update " \
+                'fields' if ops.empty?
+          ops
+        end
+      end
+    end
+  end
+end

data/lib/flapjack-diner/resources/notifications.rb

@@ -0,0 +1,27 @@
+require 'httparty'
+require 'json'
+require 'uri'
+
+require 'flapjack-diner/version'
+require 'flapjack-diner/argument_validator'
+
+module Flapjack
+  module Diner
+    module Resources
+      module Notifications
+        %w(entities checks).each do |data_type|
+          define_method("create_test_notifications_#{data_type}") do |*args|
+            ids, data = unwrap_ids(*args), unwrap_create_data(*args)
+            raise "'create_test_notifications_#{data_type}' requires at " \
+              "least one #{data_type} id parameter" if ids.nil? || ids.empty?
+            validate_params(data) do
+              validate :query => :summary, :as => :string
+            end
+            perform_post("/test_notifications/#{data_type}", ids,
+                         :test_notifications => data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack-diner/resources/pagerduty_credentials.rb

@@ -0,0 +1,60 @@
+require 'httparty'
+require 'json'
+require 'uri'
+
+require 'flapjack-diner/version'
+require 'flapjack-diner/argument_validator'
+
+module Flapjack
+  module Diner
+    module Resources
+      module PagerdutyCredentials
+        def create_contact_pagerduty_credentials(*args)
+          ids, data = unwrap_ids(*args), unwrap_create_data(*args)
+          raise "'create_contact_pagerduty_credentials' requires at least " \
+                'one contact id parameter' if ids.nil? || ids.empty?
+          validate_params(data) do
+            validate :query => [:service_key], :as => [:required, :string]
+          end
+          perform_post("/contacts/#{escaped_ids(ids)}/pagerduty_credentials",
+                       nil, :pagerduty_credentials => data)
+        end
+
+        def pagerduty_credentials(*ids)
+          perform_get('pagerduty_credentials', '/pagerduty_credentials', ids)
+        end
+
+        def update_pagerduty_credentials(*args)
+          ids, params = unwrap_ids(*args), unwrap_params(*args)
+          raise "'update_pagerduty_credentials' requires at least one " \
+                ' pagerduty_credentials id parameter' if ids.nil? || ids.empty?
+          validate_params(params) do
+            validate :query => [:service_key, :subdomain,
+                                :username, :password], :as => :string
+          end
+          perform_patch("/pagerduty_credentials/#{escaped_ids(ids)}",
+                        nil, update_pagerduty_credentials_ops(params))
+        end
+
+        def delete_pagerduty_credentials(*ids)
+          raise "'delete_pagerduty_credentials' requires at least one " \
+                'pagerduty_credentials id parameter' if ids.nil? || ids.empty?
+          perform_delete('/pagerduty_credentials', ids)
+        end
+
+        private
+
+        def update_pagerduty_credentials_ops(params)
+          ops = params.each_with_object([]) do |(k, v), memo|
+            next unless [:service_key, :subdomain,
+                         :username, :password].include?(k)
+            memo << patch_replace('pagerduty_credentials', k, v)
+          end
+          raise "'update_pagerduty_credentials' did not find any valid " \
+                'update fields' if ops.empty?
+          ops
+        end
+      end
+    end
+  end
+end

data/lib/flapjack-diner/resources/reports.rb

@@ -0,0 +1,33 @@
+require 'httparty'
+require 'json'
+require 'uri'
+
+require 'flapjack-diner/version'
+require 'flapjack-diner/argument_validator'
+
+module Flapjack
+  module Diner
+    module Resources
+      module Reports
+        %w(entities checks).each do |data_type|
+          define_method("status_report_#{data_type}") do |*ids|
+            perform_get('status_reports', "/status_report/#{data_type}", ids)
+          end
+
+          %w(scheduled_maintenance unscheduled_maintenance
+             downtime outage).each do |report_type|
+            define_method("#{report_type}_report_#{data_type}") do |*args|
+              ids, params = unwrap_ids(*args), unwrap_params(*args)
+              validate_params(params) do
+                validate :query => [:start_time, :end_time], :as => :time
+              end
+              perform_get("#{report_type}_reports",
+                          "/#{report_type}_report/#{data_type}",
+                          ids, params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack-diner/tools.rb

@@ -0,0 +1,277 @@
+require 'uri'
+
+module Flapjack
+  module Diner
+    module Tools
+      SUCCESS_STATUS_CODES = [200, 201, 204]
+
+      attr_accessor :last_error
+
+      private
+
+      def log_request(method_type, req_uri, data = nil)
+        return if logger.nil? || req_uri.nil?
+        log_msg = "#{method_type} #{req_uri}"
+        unless %w(GET DELETE).include?(method_type) || data.nil?
+          log_msg << "\n  Body: #{data.inspect}"
+        end
+        logger.info log_msg
+      end
+
+      def perform_get(name, path, ids = [], data = nil)
+        @last_error = nil
+        req_uri = build_uri(path, ids, data)
+        log_request('GET', req_uri, data)
+        handled = handle_response(get(req_uri.request_uri))
+
+        result = (!handled.nil? && handled.is_a?(Hash)) ? handled[name] :
+                 handled
+
+        return_keys_as_strings.is_a?(TrueClass) ? result : symbolize(result)
+      end
+
+      def perform_post(path, ids = [], data = nil)
+        @last_error = nil
+        req_uri = build_uri(path, ids)
+        log_request('POST', req_uri, data)
+        opts = if data.nil?
+                 {}
+               else
+                 {:body => prepare_nested_query(data).to_json,
+                  :headers => {'Content-Type' => 'application/vnd.api+json'}}
+               end
+        handle_response(post(req_uri.request_uri, opts))
+      end
+
+      def perform_patch(path, ids = [], data = nil)
+        @last_error = nil
+        req_uri = build_uri(path, ids)
+        log_request('PATCH', req_uri, data)
+        opts = if data.nil?
+                 {}
+               else
+                 {:body    => prepare_nested_query(data).to_json,
+                  :headers => {'Content-Type' => 'application/json-patch+json'}}
+               end
+        handle_response(patch(req_uri.request_uri, opts))
+      end
+
+      def perform_delete(path, ids = [], data = nil)
+        @last_error = nil
+        req_uri = build_uri(path, ids, data)
+        log_request('DELETE', req_uri, data)
+        handle_response(delete(req_uri.request_uri))
+      end
+
+      def log_response(response)
+        return if logger.nil? || !response.respond_to?(:code)
+        response_message = "  Response Code: #{response.code}"
+        unless response.message.nil? || (response.message.eql?(''))
+          response_message << " #{response.message}"
+        end
+        logger.info response_message
+        return if response.body.nil?
+        logger.info "  Response Body: #{response.body[0..300]}"
+      end
+
+      def handle_response(response)
+        log_response(response)
+        return true if 204.eql?(response.code)
+        parsed = if response.respond_to?(:parsed_response)
+                   response.parsed_response
+                 else
+                   nil
+                 end
+        return parsed if [200, 201].include?(response.code)
+        @last_error = handle_error(response.code, parsed)
+        nil
+      end
+
+      def handle_error(code, parsed)
+        case parsed
+        when Hash
+          err = {'status_code' => code}.merge(parsed)
+          return_keys_as_strings.is_a?(TrueClass) ? err : symbolize(err)
+        else
+          parsed
+        end
+      end
+
+      def validate_params(query = {}, &validation)
+        return unless block_given?
+        case query
+        when Array
+          query.each do |q|
+            ArgumentValidator.new(q).instance_eval(&validation)
+          end
+        else
+          ArgumentValidator.new(query).instance_eval(&validation)
+        end
+      end
+
+      # copied from Rack::Utils -- builds the query string for GETs
+      def build_nested_query(value, prefix = nil)
+        case value
+        when Array
+          build_array_query(value, prefix)
+        when Hash
+          build_hash_query(value, prefix)
+        else
+          build_data_query(value, prefix)
+        end
+      end
+
+      def build_array_query(value, prefix)
+        value.map {|v| build_nested_query(v, "#{prefix}[]") }.join('&')
+      end
+
+      def build_hash_query(value, prefix)
+        value.map do |k, v|
+          data = prefix ? "#{prefix}[#{escape(k)}]" : escape(k)
+          build_nested_query(v, data)
+        end.join('&')
+      end
+
+      def build_data_query(value, prefix)
+        if value.respond_to?(:iso8601)
+          raise(ArgumentError, 'Value must be a Hash') if prefix.nil?
+          "#{prefix}=#{escape(value.iso8601)}"
+        elsif value.is_a?(String) || value.is_a?(Integer)
+          raise(ArgumentError, 'Value must be a Hash') if prefix.nil?
+          "#{prefix}=#{escape(value.to_s)}"
+        else
+          prefix
+        end
+      end
+
+      def escaped_ids(ids = [])
+        ids.map {|id| URI.escape(id.to_s) }.join(',')
+      end
+
+      def escape(s)
+        URI.encode_www_form_component(s)
+      end
+
+      def unwrap_ids(*args)
+        args.select {|a| a.is_a?(String) || a.is_a?(Integer) }
+      end
+
+      def unwrap_params(*args)
+        args.each_with_object({}) do |e, a|
+          a.update(symbolize(e)) if e.is_a?(Hash)
+        end
+      end
+
+      def unwrap_data(*args)
+        args.select {|a| a.is_a?(Array) && a.all? {|av| av.is_a?(Hash) } }
+            .reduce([], &:'+')
+      end
+
+      def unwrap_create_data(*args)
+        data_h = args.select {|a| a.is_a?(Hash) }
+        data_a = unwrap_data(*args)
+
+        raise 'Create data may be passed as a Hash or an Array of Hashes, ' \
+              'not both' unless data_h.empty? || data_a.empty?
+
+        data = data_h
+        data = data_a if data.empty?
+        data = nil if data.empty?
+        data
+      end
+
+      def patch_replace(type, k, v)
+        {:op    => 'replace',
+         :path  => "/#{type}/0/#{k}",
+         :value => v}
+      end
+
+      def patch_add(type, linked, v)
+        {:op    => 'add',
+         :path  => "/#{type}/0/links/#{linked}/-",
+         :value => v}
+      end
+
+      def patch_remove(type, linked, v)
+        {:op    => 'remove',
+         :path  => "/#{type}/0/links/#{linked}/#{v}"}
+      end
+
+      # used for the JSON data hashes in POST, PUT, DELETE
+      def prepare_nested_query(value)
+        case value
+        when Array
+          prepare_array_query(value)
+        when Hash
+          prepare_hash_query(value)
+        else
+          prepare_data_query(value)
+        end
+      end
+
+      def prepare_array_query(value)
+        value.map {|v| prepare_nested_query(v) }
+      end
+
+      def prepare_hash_query(value)
+        value.each_with_object({}) do |(k, v), a|
+          a[k] = prepare_nested_query(v)
+        end
+      end
+
+      def prepare_data_query(value)
+        if value.respond_to?(:iso8601)
+          value.iso8601
+        else
+          case value
+          when Integer, TrueClass, FalseClass, NilClass
+            value
+          else
+            value.to_s
+          end
+        end
+      end
+
+      def normalise_port(port_str, protocol)
+        if port_str.nil? || port_str.to_i < 1 || port_str.to_i > 65_535
+          'https'.eql?(protocol) ? 443 : 80
+        else
+          port_str.to_i
+        end
+      end
+
+      def protocol_host_port
+        %r{^(?:(?<protocol>https?)://)
+           (?<host>[a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])
+           (?::(?<port>\d+))?
+        }ix =~ base_uri
+
+        protocol = protocol.nil? ? 'http' : protocol.downcase
+        [protocol, host, normalise_port(port, protocol)]
+      end
+
+      def build_uri(path, ids = [], params = [])
+        pr, ho, po = protocol_host_port
+        path += '/' + escaped_ids(ids) unless ids.nil? || ids.empty?
+        query = if params.nil? || params.empty?
+                  nil
+                else
+                  build_nested_query(params)
+                end
+        URI::HTTP.build(:protocol => pr, :host => ho, :port => po,
+          :path => path, :query => query)
+      end
+
+      def symbolize(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) {|(k, v), a| a[k.to_sym] = symbolize(v) }
+        when Array
+          obj.each_with_object([]) {|e, a| a << symbolize(e) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end