flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/data/unscheduled_maintenance.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+require 'swagger/blocks'
+
+require 'zermelo/records/redis'
+
+require 'flapjack/data/extensions/short_name'
+require 'flapjack/data/validators/id_validator'
+
+require 'flapjack/data/extensions/associations'
+require 'flapjack/gateways/jsonapi/data/join_descriptor'
+require 'flapjack/gateways/jsonapi/data/method_descriptor'
+
+module Flapjack
+  module Data
+    class UnscheduledMaintenance
+
+      include Zermelo::Records::RedisSortedSet
+      include ActiveModel::Serializers::JSON
+      self.include_root_in_json = false
+      include Swagger::Blocks
+
+      include Flapjack::Data::Extensions::Associations
+      include Flapjack::Data::Extensions::ShortName
+
+      define_attributes :start_time => :timestamp,
+                        :end_time   => :timestamp,
+                        :summary    => :string
+
+      define_sort_attribute :start_time
+
+      belongs_to :check, :class_name => 'Flapjack::Data::Check',
+        :inverse_of => :unscheduled_maintenances
+
+      # TODO :check before_set -- should fail if already set
+
+      range_index_by :start_time, :end_time
+
+      before_validation :ensure_start_time
+
+      validates :start_time, :presence => true
+      validates :end_time, :presence => true
+
+      validates_with Flapjack::Data::Validators::IdValidator
+
+      def duration
+        self.end_time - self.start_time
+      end
+
+      swagger_schema :UnscheduledMaintenance do
+        key :required, [:id, :type, :start_time, :end_time]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::UnscheduledMaintenance.short_model_name.singular]
+        end
+        property :start_time do
+          key :type, :string
+          key :format, :"date-time"
+        end
+        property :end_time do
+          key :type, :string
+          key :format, :"date-time"
+        end
+        property :relationships do
+          key :"$ref", :UnscheduledMaintenanceLinks
+        end
+      end
+
+      swagger_schema :UnscheduledMaintenanceLinks do
+        key :required, [:check]
+        property :check do
+          key :"$ref", :CheckLinkage
+        end
+      end
+
+      swagger_schema :UnscheduledMaintenanceUpdate do
+        key :required, [:id, :type]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::UnscheduledMaintenance.short_model_name.singular]
+        end
+        property :end_time do
+          key :type, :string
+          key :format, :"date-time"
+        end
+      end
+
+      def self.swagger_included_classes
+        # hack -- hardcoding for now
+        [
+          Flapjack::Data::Check,
+          Flapjack::Data::Contact,
+          Flapjack::Data::Medium,
+          Flapjack::Data::Rule,
+          Flapjack::Data::ScheduledMaintenance,
+          Flapjack::Data::State,
+          Flapjack::Data::Tag,
+          Flapjack::Data::UnscheduledMaintenance
+        ]
+      end
+
+      def self.jsonapi_methods
+        @jsonapi_methods ||= {
+          :get => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:start_time, :end_time, :summary],
+            :descriptions => {
+              :singular => "Get data for an un scheduled maintenance period.",
+              :multiple => "Get data for multiple unscheduled maintenance periods."
+            }
+          ),
+          :patch => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:start_time, :end_time, :summary],
+            :descriptions => {
+              :singular => "Update data for an unscheduled maintenance period.",
+              :multiple => "Update data for unscheduled maintenance periods.",
+            }
+          ),
+          :delete => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :descriptions => {
+              :singular => "Delete an scheduled maintenance period.",
+              :multiple => "Delete unscheduled maintenance periods."
+            }
+          )
+        }
+      end
+
+      def self.jsonapi_associations
+        unless instance_variable_defined?('@jsonapi_associations')
+          @jsonapi_associations ||= {
+            :check => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :get => true,
+              :number => :singular, :link => true, :includable => true,
+              :descriptions => {
+                :get => "Returns the check an unscheduled maintenance period applies to."
+              }
+            )
+          }
+          populate_association_data(@jsonapi_associations)
+        end
+        @jsonapi_associations
+      end
+
+      private
+
+      def ensure_start_time
+        self.start_time ||= Time.now
+      end
+
+    end
+  end
+end

data/lib/flapjack/data/validators/id_validator.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'flapjack'
+
+module Flapjack
+  module Data
+    module Validators
+      class IdValidator < ActiveModel::Validator
+
+        UUID_REGEXP = /^#{Flapjack::UUID_RE}$/
+
+        def validate(record)
+          if !record.id.nil? && UUID_REGEXP.match(record.id.to_s).nil?
+            record.errors.add(:id, 'is not a UUID')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/exceptions.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+module Flapjack
+  class PikeletStop < StandardError; end
+  class GlobalStop < StandardError; end
+end

data/lib/flapjack/filters/acknowledgement.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'flapjack/data/unscheduled_maintenance'
+
 require 'flapjack/filters/base'
 
 module Flapjack
@@ -11,32 +13,37 @@ module Flapjack
     class Acknowledgement
       include Base
 
-      def block?(event, entity_check, previous_state)
-        timestamp = Time.now.to_i
+      def block?(check, opts = {})
+        old_state = opts[:old_state]
+        new_state = opts[:new_state]
+        timestamp = opts[:timestamp]
 
         label = 'Filter: Acknowledgement:'
 
-        return false unless event.type == 'action'
-
-        unless event.acknowledgement?
-          @logger.debug("#{label} pass (not an ack)")
+        unless 'acknowledgement'.eql?(new_state.action)
+          Flapjack.logger.debug { "#{label} pass (not an ack)" }
           return false
         end
 
-        if entity_check.nil?
-          @logger.error "#{label} unknown entity for event '#{event.id}'"
-          return false
-        end
-
-        unless @redis.zscore("failed_checks", event.id)
-          @logger.debug("#{label} blocking because zscore of failed_checks for #{event.id} is false")
+        if old_state.nil? || Flapjack::Data::Condition.healthy?(old_state.condition)
+          Flapjack.logger.debug {
+            "#{label} blocking because check '#{check.name}' is not failing"
+          }
           return true
         end
 
-        um_duration = event.duration || (4 * 60 * 60)
-        entity_check.create_unscheduled_maintenance(timestamp, um_duration, :summary  => event.summary)
+        end_time = timestamp + (opts[:duration] || (4 * 60 * 60))
+
+        unsched_maint = Flapjack::Data::UnscheduledMaintenance.new(:start_time => timestamp,
+          :end_time => end_time, :summary => new_state.summary)
+        unsched_maint.save
+
+        check.set_unscheduled_maintenance(unsched_maint)
 
-        @logger.debug("#{label} pass (unscheduled maintenance created for #{event.id}, duration: #{um_duration})")
+        Flapjack.logger.debug{
+          "#{label} pass (unscheduled maintenance created for #{check.name}, " \
+          " duration: #{end_time - timestamp})"
+        }
         false
       end
     end

data/lib/flapjack/filters/base.rb

@@ -3,11 +3,6 @@
 module Flapjack
   module Filters
     module Base
-      def initialize(opts={})
-        @logger = opts[:logger]
-        @redis  = opts[:redis]
-      end
-
       def name
         self.class.to_s.split('::').last
       end

data/lib/flapjack/filters/delays.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
-require 'flapjack/data/entity_check'
+require 'flapjack'
+
 require 'flapjack/filters/base'
 
 module Flapjack
@@ -19,65 +20,74 @@ module Flapjack
     class Delays
       include Base
 
-      def block?(event, entity_check, previous_state)
-        initial_failure_delay = entity_check.initial_failure_delay
-        if initial_failure_delay.nil? || (initial_failure_delay < 0)
-          initial_failure_delay = Flapjack::DEFAULT_INITIAL_FAILURE_DELAY
-        end
+      def block?(check, opts = {})
+        old_state = opts[:old_state]
+        new_state = opts[:new_state]
+        timestamp = opts[:timestamp]
 
-        repeat_failure_delay = entity_check.repeat_failure_delay
-        if repeat_failure_delay.nil? || (repeat_failure_delay < 0)
-          repeat_failure_delay = Flapjack::DEFAULT_REPEAT_FAILURE_DELAY
-        end
+        initial_failure_delay = opts[:initial_failure_delay]
+        repeat_failure_delay = opts[:repeat_failure_delay]
 
         label = 'Filter: Delays:'
 
-        unless event.service? && event.failure?
-          @logger.debug("#{label} pass - not a service event in a failure state")
-          return false
-        end
+        if new_state.nil? || !new_state.action.nil? ||
+          Flapjack::Data::Condition.healthy?(new_state.condition)
 
-        unless entity_check.failed?
-          @logger.debug("#{label} entity_check.failed? returned false ...")
+          Flapjack.logger.debug {
+            "#{label} pass - not a service event in a failure state"
+          }
           return false
         end
 
-        last_problem_alert   = entity_check.last_notification_for_state(:problem)[:timestamp]
-        last_change          = entity_check.last_change
-        last_alert_state     = entity_check.last_notification[:type]
-
-        current_time = Time.now.to_i
-        current_state_duration = current_time - last_change
-        time_since_last_alert  = current_time - last_problem_alert unless last_problem_alert.nil?
-
-        @logger.debug("#{label} last_problem_alert: #{last_problem_alert.to_s}, " +
-                      "last_change: #{last_change.inspect}, " +
-                      "current_state_duration: #{current_state_duration.inspect}, " +
-                      "time_since_last_alert: #{time_since_last_alert.inspect}, " +
-                      "last_alert_state: [#{last_alert_state.inspect}], " +
-                      "event.state: [#{event.state.inspect}], " +
-                      "last_alert_state == event.state ? #{last_alert_state.to_s == event.state}")
-
-        if current_state_duration < initial_failure_delay
-          @logger.debug("#{label} block - duration of current failure " +
-                     "(#{current_state_duration}) is less than initial_failure_delay (#{initial_failure_delay})")
+        last_problem  = check.latest_notifications.
+          intersect(:condition => Flapjack::Data::Condition.unhealthy.keys).first
+        last_recovery = check.latest_notifications.
+          intersect(:condition => Flapjack::Data::Condition.healthy.keys).first
+        last_ack      = check.latest_notifications.
+          intersect(:action => 'acknowledgement').first
+
+        last_problem_time  = last_problem.nil?  ? nil : last_problem.created_at
+        last_notif = [last_problem, last_recovery, last_ack].compact.
+                       sort_by(&:created_at).last
+
+        last_change_time = old_state.nil? ? nil : old_state.created_at
+
+        alert_type = Flapjack::Data::Alert.notification_type(new_state.action,
+          new_state.condition)
+
+        last_alert_type = last_notif.nil? ? nil :
+          Flapjack::Data::Alert.notification_type(last_notif.action, last_notif.condition)
+
+        current_condition_duration = last_change_time.nil? ? nil : (timestamp - last_change_time)
+        time_since_last_alert = last_problem_time.nil? ? nil : (timestamp - last_problem_time)
+
+        Flapjack.logger.debug("#{label} last_problem: #{last_problem_time || 'nil'}, " +
+                      "last_change: #{last_change_time || 'nil'}, " +
+                      "current_condition_duration: #{current_condition_duration || 'nil'}, " +
+                      "time_since_last_alert: #{time_since_last_alert || 'nil'}, " +
+                      "alert type: [#{alert_type}], " +
+                      "last_alert_type == alert_type ? #{last_alert_type == alert_type}")
+
+        if !current_condition_duration.nil? && (current_condition_duration < initial_failure_delay)
+          Flapjack.logger.debug("#{label} block - duration of current failure " +
+                     "(#{current_condition_duration}) is less than failure_delay (#{initial_failure_delay})")
           return true
         end
 
-        if !last_problem_alert.nil? && (time_since_last_alert < repeat_failure_delay) &&
-          (last_alert_state.to_s == event.state)
+        if !(last_problem_time.nil? || time_since_last_alert.nil?) &&
+          (time_since_last_alert <= repeat_failure_delay) &&
+          (last_alert_type == alert_type)
 
-          @logger.debug("#{label} block - time since last alert for " +
+          Flapjack.logger.debug("#{label} block - time since last alert for " +
                         "current problem (#{time_since_last_alert}) is less than " +
-                        "repeat_failure_delay (#{repeat_failure_delay}) and last alert state (#{last_alert_state}) " +
-                        "is equal to current event state (#{event.state})")
+                        "repeat_failure_delay (#{repeat_failure_delay}) and last alert type (#{last_alert_type}) " +
+                        "is equal to current alert type (#{alert_type})")
           return true
         end
 
-        @logger.debug("#{label} pass - not blocking because neither of the time comparison " +
+        Flapjack.logger.debug("#{label} pass - not blocking because neither of the time comparison " +
                       "conditions were met")
-        return false
-
+        false
       end
     end
   end

data/lib/flapjack/filters/ok.rb

@@ -13,34 +13,43 @@ module Flapjack
     class Ok
       include Base
 
-      def block?(event, entity_check, previous_state)
-        unless event.ok?
-          @logger.debug("Filter: Ok: pass")
+      def block?(check, opts = {})
+        old_state = opts[:old_state]
+        new_state = opts[:new_state]
+        timestamp = opts[:timestamp]
+
+        if !new_state.nil? && !(new_state.action.nil? &&
+          Flapjack::Data::Condition.healthy?(new_state.condition))
+
+          Flapjack.logger.debug("Filter: Ok: pass")
           return false
         end
 
-        entity_check.end_unscheduled_maintenance(Time.now.to_i)
+        check.clear_unscheduled_maintenance(timestamp)
 
-        if previous_state == 'ok'
-          @logger.debug("Filter: Ok: block - previous state was ok, so blocking")
+        if old_state.nil? || Flapjack::Data::Condition.healthy?(old_state.condition)
+          Flapjack.logger.debug("Filter: Ok: block - previous state was ok, so blocking")
+          Flapjack.logger.debug(old_state.inspect)
+          Flapjack.logger.debug(new_state.inspect) unless new_state.nil?
           return true
         end
 
-        last_notification = entity_check.last_notification
-        @logger.debug("Filter: Ok: last notification: #{last_notification.inspect}")
+        last_notification = check.latest_notifications.first
 
-        unless last_notification[:type]
-          @logger.debug("Filter: Ok: block - last notification type is nil (never notified)")
+        if last_notification.nil?
+          Flapjack.logger.debug("Filter: Ok: block - last notification is nil (never notified)")
           return true
         end
 
-        if [:recovery, :ok].include?(last_notification[:type])
-          @logger.debug("Filter: Ok: block - last notification was a recovery")
+        Flapjack.logger.debug("Filter: Ok: last notification: #{last_notification.inspect}")
+
+        if Flapjack::Data::Condition.healthy?(last_notification.condition)
+          Flapjack.logger.debug("Filter: Ok: block - last notification was a recovery")
           return true
         end
 
-        @logger.debug("Filter: Ok: previous_state: #{previous_state}")
-        @logger.debug("Filter: Ok: pass")
+        Flapjack.logger.debug("Filter: Ok: old_state: #{old_state.inspect}")
+        Flapjack.logger.debug("Filter: Ok: pass")
         false
       end
     end

data/lib/flapjack/filters/scheduled_maintenance.rb

@@ -7,9 +7,9 @@ module Flapjack
     class ScheduledMaintenance
       include Base
 
-      def block?(event, entity_check, previous_state)
-        result = entity_check.in_scheduled_maintenance?
-        @logger.debug("Filter: Scheduled Maintenance: #{result ? "block" : "pass"}")
+      def block?(check, opts = {})
+        result = check.in_scheduled_maintenance?
+        Flapjack.logger.debug("Filter: Scheduled Maintenance: #{result ? "block" : "pass"}")
         result
       end
     end