flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/data/rule.rb

@@ -0,0 +1,473 @@
+#!/usr/bin/env ruby
+
+require 'set'
+
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/slice'
+
+require 'ice_cube'
+require 'icalendar'
+require 'swagger/blocks'
+
+require 'zermelo/records/redis'
+
+require 'flapjack/utility'
+
+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 Rule
+
+      STRATEGIES = ['global', 'any_tag', 'all_tags', 'no_tag']
+
+      extend Flapjack::Utility
+
+      include Zermelo::Records::RedisSet
+      include ActiveModel::Serializers::JSON
+      self.include_root_in_json = false
+      include Swagger::Blocks
+
+      include Flapjack::Data::Extensions::Associations
+      include Flapjack::Data::Extensions::ShortName
+
+      # regex_* properties have been removed as they encourage loose binding
+      # against check names, which may change. Do client-side grouping and
+      # create a tag!
+
+      define_attributes :name => :string,
+                        :enabled => :boolean,
+                        :blackhole => :boolean,
+                        :strategy => :string,
+                        :conditions_list => :string,
+                        :has_media => :boolean,
+                        :time_restriction_ical => :string
+
+      index_by :name, :enabled, :blackhole, :strategy, :conditions_list, :has_media
+
+      validates_with Flapjack::Data::Validators::IdValidator
+
+      validates :enabled, :inclusion => {:in => [true, false]}
+      validates :blackhole, :inclusion => {:in => [true, false]}
+      validates :strategy, :inclusion => {:in => Flapjack::Data::Rule::STRATEGIES}
+
+      validates_each :time_restriction_ical do |record, att, value|
+        unless record.valid_time_restriction_ical?
+          record.errors.add(:time_restriction_ical, 'is not valid ICAL syntax')
+        end
+      end
+
+      belongs_to :contact, :class_name => 'Flapjack::Data::Contact',
+        :inverse_of => :rules
+
+      has_and_belongs_to_many :media, :class_name => 'Flapjack::Data::Medium',
+        :inverse_of => :rules, :after_add => :media_added,
+        :after_remove => :media_removed
+
+      has_and_belongs_to_many :tags, :class_name => 'Flapjack::Data::Tag',
+        :inverse_of => :rules
+
+      def initialize(attributes = {})
+        super
+        send(:"attribute=", 'has_media', false)
+      end
+
+      def time_restriction
+        return if time_restriction_ical.nil? || !valid_time_restriction_ical?
+        IceCube::Schedule.from_ical(time_restriction_ical)
+      end
+
+      def time_restriction=(restriction)
+        if restriction.nil?
+          self.time_restriction_ical = nil
+          return
+        end
+        unless restriction.is_a?(IceCube::Schedule)
+          raise "Invalid data type for time_restriction= (#{restriction.class.name})"
+        end
+        # ice_cube ignores time zone info when parsing ical, so we'll enforce UTC
+        # and cast to the contact's preferred time zone as appropriate when using
+        # (this should also handle the case of the user changing her timezone)
+        restriction.start_time = restriction.start_time.nil? ? nil : restriction.start_time.utc
+        restriction.end_time = restriction.end_time.nil? ? nil : restriction.end_time.utc
+        self.time_restriction_ical = restriction.to_ical
+      end
+
+      def valid_time_restriction_ical?
+        return true if time_restriction_ical.nil?
+        wrapped_value = ['BEGIN:VCALENDAR',
+                         'VERSION:2.0',
+                         'PRODID:validationid',
+                         'CALSCALE:GREGORIAN',
+                         'BEGIN:VEVENT',
+                         time_restriction_ical,
+                         'END:VEVENT',
+                         'END:VCALENDAR'].join("\n")
+
+        # icalendar is noisy with errors
+        old_icalendar_log_level = ::Icalendar.logger.level
+        ::Icalendar.logger.level = ::Logger::FATAL
+        icalendar = ::Icalendar.parse(wrapped_value)
+        ::Icalendar.logger.level = old_icalendar_log_level
+
+        !(icalendar.empty? || icalendar.first.events.empty? ||
+          !icalendar.first.events.first.valid?)
+      end
+
+      # nil time_restriction matches
+      def is_occurring_at?(time, time_zone = Time.zone)
+        return true if time_restriction.nil?
+        time_restriction.occurring_at?(time.in_time_zone(time_zone))
+      end
+
+      def self.media_added(rule_id, *m_ids)
+        rule = self.find_by_id!(rule_id)
+        rule.has_media = true
+        rule.save!
+      end
+
+      def self.media_removed(rule_id, *m_ids)
+        rule = self.find_by_id!(rule_id)
+        rule.has_media = rule.media.empty?
+        rule.save!
+      end
+
+      # called by medium.checks
+      # no global rules in the passed rule data
+      # rule_ids will be all acceptors
+      # (blackhole == false) or all rejectors (blackhole == true)
+      def self.matching_checks(rule_ids)
+        m_checks = ['all_tags', 'any_tag', 'no_tag'].inject(nil) do |memo, strategy|
+          tag_ids_by_rule_id = self.intersect(:strategy => strategy,
+            :id => rule_ids).associated_ids_for(:tags)
+
+          checks = checks_for_tag_match(strategy, tag_ids_by_rule_id)
+
+          memo = if memo.nil?
+            Flapjack::Data::Check.intersect(:id => checks)
+          else
+            memo.union(:id => checks)
+          end
+        end
+
+        return Flapjack::Data::Check.empty if m_checks.nil?
+        m_checks
+      end
+
+      # called by check.contacts, rule_ids will be all acceptors
+      # (blackhole == false) or all rejectors (blackhole == true)
+      def self.matching_contact_ids(rule_ids, opts = {})
+        time = opts[:time] || Time.now
+        contact_rules = self.intersect(:id => rule_ids)
+
+        matching_ids = apply_time_restriction(contact_rules, time).
+          map(&:id)
+
+        self.intersect(:id => matching_ids).
+          associated_ids_for(:contact, :inversed => true).keys
+      end
+
+      # called by check.alerting_media, rule_ids will be all acceptors
+      # (blackhole == false) or all rejectors (blackhole == true)
+      def self.matching_media_ids(rule_ids, opts = {})
+        time = opts[:time] || Time.now
+
+        # if a rule has no media, it's irrelevant here
+        media_rules = self.intersect(:id => rule_ids, :has_media => true)
+
+        matching_ids = apply_time_restriction(media_rules, time).
+          map(&:id)
+
+        self.intersect(:id => matching_ids).
+          associated_ids_for(:media).values.reduce(Set.new, :|)
+      end
+
+      swagger_schema :Rule do
+        key :required, [:id, :type, :enabled, :blackhole, :strategy]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::Rule.short_model_name.singular]
+        end
+        property :name do
+          key :type, :string
+        end
+        property :enabled do
+          key :type, :boolean
+        end
+        property :blackhole do
+          key :type, :boolean
+        end
+        property :strategy do
+          key :type, :string
+          key :enum, Flapjack::Data::Rule::STRATEGIES
+        end
+        property :conditions_list do
+          key :type, :string
+        end
+        property :time_restriction_ical do
+          key :type, :string
+        end
+        property :relationships do
+          key :"$ref", :RuleLinks
+        end
+      end
+
+      swagger_schema :RuleLinks do
+        key :required, [:contact, :media, :tags]
+        property :contact do
+          key :"$ref", :ContactLinkage
+        end
+        property :media do
+          key :"$ref", :MediaLinkage
+        end
+        property :tags do
+          key :"$ref", :TagsLinkage
+        end
+      end
+
+      swagger_schema :RuleCreate do
+        key :required, [:type, :enabled, :blackhole, :strategy]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::Rule.short_model_name.singular]
+        end
+        property :name do
+          key :type, :string
+        end
+        property :enabled do
+          key :type, :boolean
+        end
+        property :blackhole do
+          key :type, :boolean
+        end
+        property :strategy do
+          key :type, :string
+          key :enum, Flapjack::Data::Rule::STRATEGIES
+        end
+        property :conditions_list do
+          key :type, :string
+        end
+        property :time_restriction_ical do
+          key :type, :string
+        end
+        property :relationships do
+          key :"$ref", :RuleCreateLinks
+        end
+      end
+
+      swagger_schema :RuleCreateLinks do
+        key :required, [:contact]
+        property :contact do
+          key :"$ref", :data_ContactReference
+        end
+        property :media do
+          key :"$ref", :data_MediaReference
+        end
+        property :tags do
+          key :"$ref", :data_TagsReference
+        end
+      end
+
+      swagger_schema :RuleUpdate 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::Rule.short_model_name.singular]
+        end
+        property :name do
+          key :type, :string
+        end
+        property :enabled do
+          key :type, :boolean
+        end
+        property :blackhole do
+          key :type, :boolean
+        end
+        property :strategy do
+          key :type, :string
+          key :enum, Flapjack::Data::Rule::STRATEGIES
+        end
+        property :conditions_list do
+          key :type, :string
+        end
+        property :time_restriction_ical do
+          key :type, :string
+        end
+        property :relationships do
+          key :"$ref", :RuleUpdateLinks
+        end
+      end
+
+      swagger_schema :RuleUpdateLinks do
+        property :media do
+          key :"$ref", :data_MediaReference
+        end
+        property :tags do
+          key :"$ref", :data_TagsReference
+        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 ||= {
+          :post => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:name, :enabled, :blackhole, :strategy, :conditions_list,
+              :time_restriction_ical],
+            :descriptions => {
+              :singular => "Create a notification rule.",
+              :multiple => "Create notification rules."
+            }
+          ),
+          :get => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:name, :enabled, :blackhole, :strategy, :conditions_list,
+              :time_restriction_ical],
+            :descriptions => {
+              :singular => "Get data for a notification rule.",
+              :multiple => "Get data for multiple notification rules."
+            }
+          ),
+          :patch => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:name, :enabled, :blackhole, :strategy, :conditions_list,
+              :time_restriction_ical],
+            :descriptions => {
+              :singular => "Update a notification rule.",
+              :multiple => "Update notification rules."
+            }
+          ),
+          :delete => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :descriptions => {
+              :singular => "Delete a notification rule.",
+              :multiple => "Delete notification rules."
+            }
+          )
+        }
+      end
+
+      def self.jsonapi_associations
+        unless instance_variable_defined?('@jsonapi_associations')
+          @jsonapi_associations = {
+            :contact => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true, :get => true,
+              :number => :singular, :link => true, :includable => true,
+              :descriptions => {
+                :post => "Set a contact for a rule during rule creation (required).",
+                :get => "Get the contact a rule belongs to."
+              }
+            ),
+            :media => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true, :get => true, :patch => true, :delete => true,
+              :number => :multiple, :link => true, :includable => true,
+              :descriptions => {
+                :post => "Associate this rule with media on rule creation.",
+                :get => "Get the media this rule is associated with.",
+                :patch => "Update the media this rule is associated with.",
+                :delete => "Delete associations between this rule and media."
+              }
+            ),
+            :tags => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true, :get => true, :patch => true, :delete => true,
+              :number => :multiple, :link => true, :includable => true,
+              :descriptions => {
+                :post => "Associate tags with this rule.",
+                :get => "Returns all tags linked to this rule.",
+                :patch => "Update the tags associated with this rule.",
+                :delete => "Delete associations between tags and this rule."
+              }
+            )
+          }
+          populate_association_data(@jsonapi_associations)
+        end
+        @jsonapi_associations
+      end
+
+      protected
+
+      def self.apply_time_restriction(rules, time)
+        # filter the rules by time restriction
+        rule_ids_by_contact_id = rules.associated_ids_for(:contact, :inversed => true)
+
+        rule_contacts = rule_ids_by_contact_id.empty? ? [] :
+          Flapjack::Data::Contact.find_by_ids(*rule_ids_by_contact_id.keys)
+
+        time_zones_by_rule_id = rule_contacts.each_with_object({}) do |c, memo|
+          rule_ids_by_contact_id[c.id].each do |r_id|
+            memo[r_id] = c.time_zone
+          end
+        end
+
+        rules.select do |rule|
+          rule.is_occurring_at?(time, time_zones_by_rule_id[rule.id])
+        end
+      end
+
+      private
+
+      def self.checks_for_tag_match(strategy, tag_ids_by_rule_id)
+        tag_ids_by_rule_id.values.inject(nil) do |memo, tag_ids|
+          assocs = Flapjack::Data::Tag.intersect(:id => tag_ids).
+            associations_for(:checks).values
+          next memo if assocs.empty?
+
+          checks = case strategy
+          when 'all_tags'
+            assocs.inject(Flapjack::Data::Check) do |c_memo, ca|
+              c_memo = c_memo.intersect(:id => ca)
+              c_memo
+            end
+          when 'any_tag'
+            assocs.inject(nil) do |c_memo, ca|
+              if c_memo.nil?
+                Flapjack::Data::Check.intersect(:id => ca)
+              else
+                c_memo.union(:id => ca)
+              end
+            end
+          when 'no_tag'
+            assocs.inject(Flapjack::Data::Check) do |c_memo, ca|
+              c_memo = c_memo.diff(:id => ca)
+              c_memo
+            end
+          end
+
+          memo = if memo.nil?
+            Flapjack::Data::Check.intersect(:id => checks)
+          else
+            memo.union(:id => checks)
+          end
+          memo
+        end
+      end
+    end
+  end
+end
+