flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/data/event.rb

@@ -1,35 +1,31 @@
 #!/usr/bin/env ruby
 
-require 'flapjack'
-
-require 'flapjack/data/migration'
+require 'flapjack/redis_proxy'
 
 module Flapjack
   module Data
     class Event
 
-      attr_accessor :counter, :id_hash, :tags
+      attr_accessor :counter, :id_hash
 
-      attr_reader :check, :summary, :details, :acknowledgement_id, :perfdata,
-                  :initial_failure_delay, :repeat_failure_delay
+      attr_reader :id, :summary, :details, :acknowledgement_id, :perfdata
 
-      REQUIRED_KEYS = ['type', 'state', 'entity', 'check']
-      OPTIONAL_KEYS = ['time', 'summary', 'details', 'acknowledgement_id',
-                       'duration', 'tags', 'perfdata', 'initial_failure_delay',
-                       'repeat_failure_delay']
+      # type was a required key in v1, but is superfluous
+      # tags are now ignored, tags on the checks are used for rule matching
+      REQUIRED_KEYS = %w(state check)
+      OPTIONAL_KEYS = %w(entity time initial_failure_delay
+        repeat_failure_delay summary details acknowledgement_id duration tags
+        perfdata type)
 
       VALIDATIONS = {
-        proc {|e| e['type'].is_a?(String) &&
-          ['service', 'action'].include?(e['type'].downcase) } =>
-          "type must be either 'service' or 'action'",
-
         proc {|e| e['state'].is_a?(String) &&
             ['ok', 'warning', 'critical', 'unknown', 'acknowledgement',
-             'test_notifications'].include?(e['state'].downcase) } =>
+             'test_notifications'].include?(e['state'].downcase) ||
+             !(e['state'] =~ /\Atest_notifications(?:\s+#{Flapjack::Data::Condition.unhealthy.keys.join('|')})?\z/).nil? } =>
           "state must be one of 'ok', 'warning', 'critical', 'unknown', " +
-          "'acknowledgement' or 'test_notifications'",
+          "'acknowledgement', 'test_notifications', or 'test_notifications [problem]' ",
 
-        proc {|e| e['entity'].is_a?(String) } =>
+        proc {|e| e['entity'].nil? || e['entity'].is_a?(String) } =>
           "entity must be a string",
 
         proc {|e| e['check'].is_a?(String) } =>
@@ -70,93 +66,25 @@ module Flapjack
           "duration must be a positive integer, or a string castable to one",
 
         proc {|e| e['tags'].nil? ||
-                  (e['tags'].is_a?(Array) &&
-                   e['tags'].all? {|tag| tag.is_a?(String)}) } =>
+                 (e['tags'].is_a?(Array) &&
+                  e['tags'].all? {|tag| tag.is_a?(String)}) } =>
           "tags must be an array of strings",
       }
 
-      # Helper method for getting the next event.
-      #
-      # Has a blocking and non-blocking method signature.
-      #
-      # Calling next with :block => true, we wait indefinitely for events coming
-      # from other systems. This is the default behaviour.
-      #
-      # Calling next with :block => false, will return a nil if there are no
-      # events on the queue.
-      def self.next(queue, opts = {})
-        raise "Redis connection not set" unless redis = opts[:redis]
-
-        defaults = { :block => true,
-                     :archive_events => false,
-                     :events_archive_maxage => (3 * 60 * 60) }
-        options  = defaults.merge(opts)
-
-        archive_dest  = nil
-        base_time_str = Time.now.utc.strftime("%Y%m%d%H")
-
-        if options[:archive_events]
-          archive_dest = "events_archive:#{base_time_str}"
-          unless @previous_base_time_str == base_time_str
-            Flapjack::Data::Migration.purge_expired_archive_index(:redis => redis)
-          end
-          @previous_base_time_str = base_time_str
-          if options[:block]
-            raw = redis.brpoplpush(queue, archive_dest, 0)
-          else
-            raw = redis.rpoplpush(queue, archive_dest)
-            return unless raw
-          end
-          redis.sadd("known_events_archive_keys", archive_dest)
-        elsif options[:block]
-          raw = redis.brpop(queue, 0)[1]
-        else
-          raw = redis.rpop(queue)
-          return unless raw
-        end
-        parsed = parse_and_validate(raw, :logger => options[:logger])
-        if parsed.nil?
-          # either bad json or invalid data -- in either case we'll
-          # store the raw data in a rejected list
-          rejected_dest = "events_rejected:#{base_time_str}"
-          if options[:archive_events]
-            redis.multi do |multi|
-              multi.lrem(archive_dest, 1, raw)
-              multi.lpush(rejected_dest, raw)
-            end
-            redis.expire(archive_dest, options[:events_archive_maxage])
-          else
-            redis.lpush(rejected_dest, raw)
-          end
-          return
-        elsif options[:archive_events]
-          redis.expire(archive_dest, options[:events_archive_maxage])
-        end
-        self.new(parsed)
-      end
-
       def self.parse_and_validate(raw, opts = {})
         errors = []
-        if parsed = ::Flapjack.load_json(raw)
-          return if 'noop'.eql?(parsed['type'])
+        if parsed = Flapjack.load_json(raw)
           if parsed.is_a?(Hash)
             errors = validation_errors_for_hash(parsed, opts)
           else
             errors << "Event must be a JSON hash, see http://flapjack.io/docs/1.0/development/DATA_STRUCTURES#event-queue"
           end
-          return parsed if errors.empty?
-        end
-
-        if opts[:logger]
-          error_str = errors.nil? ? '' : errors.join(', ')
-          opts[:logger].error("Invalid event data received, #{error_str} #{parsed.inspect}")
+          return [parsed, errors]
         end
-        nil
-      rescue Oj::Error => e
-        if opts[:logger]
-          opts[:logger].error("Error deserialising event json: #{e}, raw json: #{raw.inspect}")
-        end
-        nil
+        [nil, errors]
+      rescue JSON::JSONError => e
+        errors << "Error deserialising event json: #{e}, raw json: #{raw.inspect}"
+        [nil, errors]
       end
 
       def self.validation_errors_for_hash(hash, opts = {})
@@ -185,67 +113,84 @@ module Flapjack
       # creates, or modifies, an event object and adds it to the events list in redis
       #   'entity'                => entity,
       #   'check'                 => check,
+      #   'time'                  => timestamp,
+      #   'initial_failure_delay' => initial_failure_delay,
+      #   'repeat_failure_delay'  => repeat_failure_delay
       #   'type'                  => 'service',
       #   'state'                 => state,
       #   'summary'               => check_output,
       #   'details'               => check_long_output,
-      #   'perfdata'              => perf_data,
-      #   'time'                  => timestamp,
-      #   'initial_failure_delay' => initial_failure_delay,
-      #   'repeat_failure_delay'  => repeat_failure_delay
-      def self.add(evt, opts = {})
-        raise "Redis connection not set" unless redis = opts[:redis]
+      #   'perfdata'              => perf_data
+      def self.push(queue, event)
+        event['time'] = Time.now.to_i if event['time'].nil?
+
+        begin
+          event_json = Flapjack.dump_json(event)
+        rescue JSON::JSONError => e
+          Flapjack.logger.warn("Error serialising event json: #{e}, event: #{event.inspect}")
+          event_json = nil
+        end
 
-        evt['time'] = Time.now.to_i if evt['time'].nil?
-        redis.lpush('events', ::Flapjack.dump_json(evt))
+        if event_json
+          Flapjack.redis.multi do
+            Flapjack.redis.lpush(queue, event_json)
+            Flapjack.redis.lpush("#{queue}_actions", "+")
+          end
+        end
       end
 
       # Provide a count of the number of events on the queue to be processed.
-      def self.pending_count(queue, opts = {})
-        raise "Redis connection not set" unless redis = opts[:redis]
-
-        redis.llen(queue)
-      end
-
-      def self.create_acknowledgement(entity_name, check, opts = {})
-        data = { 'type'               => 'action',
-                 'state'              => 'acknowledgement',
-                 'entity'             => entity_name,
-                 'check'              => check,
-                 'summary'            => opts[:summary],
-                 'duration'           => opts[:duration],
-                 'acknowledgement_id' => opts[:acknowledgement_id]
-               }
-        add(data, :redis => opts[:redis])
+      def self.pending_count(queue)
+        Flapjack.redis.llen(queue)
+      end
+
+      def self.create_acknowledgements(queue, checks, opts = {})
+        raise "Check(s) must be provided" if checks.nil?
+        checks.each do |check|
+          self.push(queue, 'state'              => 'acknowledgement',
+                           'check'              => check.name,
+                           'summary'            => opts[:summary],
+                           'duration'           => opts[:duration],
+                           'acknowledgement_id' => opts[:acknowledgement_id])
+        end
       end
 
-      def self.test_notifications(entity_name, check, opts = {})
-        data = { 'type'               => 'action',
-                 'state'              => 'test_notifications',
-                 'entity'             => entity_name,
-                 'check'              => check,
-                 'summary'            => opts[:summary],
-                 'details'            => opts[:details]
-               }
-        add(data, :redis => opts[:redis])
+      def self.test_notifications(queue, checks, opts = {})
+        raise "Check(s) must be provided" if checks.nil?
+        condition = opts[:condition] || 'critical'
+        unless Flapjack::Data::Condition.unhealthy.keys.include?(condition)
+          raise "Condition must be a problem"
+        end
+        checks.each do |check|
+          self.push(queue, 'state'              => "test_notifications #{condition}",
+                           'check'              => check.name,
+                           'summary'            => opts[:summary],
+                           'details'            => opts[:details])
+        end
       end
 
       def initialize(attrs = {})
-        ['type', 'state', 'entity', 'check', 'time', 'summary', 'details',
-         'perfdata', 'acknowledgement_id', 'duration', 'initial_failure_delay',
-         'repeat_failure_delay'].each do |key|
+        @id = if attrs['entity'].nil?
+          attrs['check']
+        else
+          "#{attrs['entity']}:#{attrs['check']}"
+        end
+        [:state, :time, :initial_failure_delay, :repeat_failure_delay,
+         :summary, :details, :perfdata, :acknowledgement_id,
+         :duration].each do |key|
 
-          instance_variable_set("@#{key}", Flapjack.sanitize(attrs[key]))
+          instance_variable_set("@#{key.to_s}", attrs[key.to_s])
         end
-        # summary is optional. set it to nil if it only contains whitespace
-        @summary = (@summary.is_a?(String) && ! @summary.strip.empty?) ? @summary.strip : nil
-        # details is optional. set it to nil if it only contains whitespace
-        @details = (@details.is_a?(String) && ! @details.strip.empty?) ? @details.strip : nil
-        # perfdata is optional. set it to nil if it only contains whitespace
-        @perfdata = (@perfdata.is_a?(String) && ! @perfdata.strip.empty?) ? @perfdata.strip : nil
-        if attrs['tags']
-          @tags = Set.new
-          attrs['tags'].each {|tag| @tags.add(tag)}
+        # summary, details and perfdata are optional. set to nil if they only contain whitespace
+        ['@summary', '@details', '@perfdata'].each do |inst|
+          value = instance_variable_get(inst)
+          v = if value.is_a?(String)
+            vs = value.strip
+            vs.empty? ? nil : vs
+          else
+            nil
+          end
+          instance_variable_set(inst, v)
         end
       end
 
@@ -254,54 +199,21 @@ module Flapjack
         @state.downcase
       end
 
-      def entity
-        return unless @entity
-        @entity.downcase
-      end
-
-      def duration
-        return unless @duration
-        @duration.to_i
-      end
-
-      def time
-        return unless @time
-        @time.to_i
-      end
-
-      def id
-        (entity || '-') + ':' + (check || '-')
-      end
-
-      def type
-        return unless @type
-        @type.downcase
-      end
-
-      def service?
-        type == 'service'
-      end
-
-      def acknowledgement?
-        (type == 'action') && (state == 'acknowledgement')
-      end
-
-      def test_notifications?
-        (type == 'action') && (state == 'test_notifications')
-      end
-
-      def ok?
-        (state == 'ok') || (state == 'up')
+      [:time, :initial_failure_delay, :repeat_failure_delay, :duration].each do |num_prop|
+        define_method(num_prop) do
+          prop = instance_variable_get("@#{num_prop}")
+          return if prop.nil?
+          prop.to_i
+        end
       end
 
-      def failure?
-        ['critical', 'warning', 'unknown', 'down', 'unreachable'].include?(state)
+      def dump
+        return @dump unless @dump.nil?
+        @dump = "#{id}, #{state}"
+        @dump << ", #{summary}" unless summary.nil?
+        @dump << ", #{Time.at(time).to_s}" unless time.nil?
       end
-
-      # # Not used anywhere
-      # def unreachable?
-      #   state == 'unreachable'
-      # end
     end
   end
 end
+

data/lib/flapjack/data/extensions/associations.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/slice'
+
+require 'sinatra/base'
+
+require 'flapjack/gateways/jsonapi/data/join_descriptor'
+require 'flapjack/gateways/jsonapi/data/method_descriptor'
+
+module Flapjack
+  module Data
+    module Extensions
+      module Associations
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def jsonapi_lock_method(http_method, locks = nil, &block)
+            locks ||= []
+
+            if :delete.eql?(http_method)
+              # all associations, not just the ones exposed via JSONAPI
+              self.send(:with_association_data) do |assoc_data|
+                assoc_data.each_pair do |name, data|
+                  locks |= [data.data_klass] + data.related_klasses
+                end
+              end
+
+              locks |= jsonapi_associations.values.select {|a|
+                !a.type.nil?
+              }.map(&:lock_klasses).reduce([], :|)
+            end
+
+            if locks.empty?
+              self.lock(&block)
+            else
+              locks.sort_by!(&:name)
+              self.lock(*locks, &block)
+            end
+          end
+
+          def populate_association_data(jsonapi_assoc)
+            # SMELL mucking about with a zermelo protected method...
+            self.send(:with_association_data) do |assoc_data|
+              assoc_data.each_pair do |name, data|
+                ja = jsonapi_assoc[name.to_sym]
+                next if ja.nil?
+                ja.association_data = data
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/data/extensions/short_name.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'securerandom'
+
+require 'active_support/concern'
+
+require 'swagger/blocks'
+
+module Flapjack
+  module Data
+    module Extensions
+      module ShortName
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def short_model_name
+            ActiveModel::Name.new(self, Flapjack::Data, self.name.demodulize)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/data/medium.rb

@@ -0,0 +1,428 @@
+#!/usr/bin/env ruby
+
+require 'swagger/blocks'
+
+require 'zermelo/records/redis'
+
+require 'flapjack/data/alert'
+require 'flapjack/data/check'
+require 'flapjack/data/contact'
+require 'flapjack/data/rule'
+require 'flapjack/data/scheduled_maintenance'
+require 'flapjack/data/unscheduled_maintenance'
+
+require 'flapjack/data/extensions/associations'
+require 'flapjack/data/extensions/short_name'
+require 'flapjack/data/validators/id_validator'
+
+require 'flapjack/gateways/jsonapi/data/join_descriptor'
+require 'flapjack/gateways/jsonapi/data/method_descriptor'
+
+module Flapjack
+
+  module Data
+
+    class Medium
+
+      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
+
+      TRANSPORTS = [
+        'email',
+        'jabber',
+        'pagerduty',
+        'sms',
+        'slack',
+        'sms_twilio',
+        'sms_nexmo',
+      	'sms_aspsms',
+        'sns'
+      ]
+
+      define_attributes :transport              => :string,
+                        :address                => :string,
+                        :interval               => :integer,
+                        :rollup_threshold       => :integer,
+                        :pagerduty_subdomain    => :string,
+                        :pagerduty_token        => :string,
+                        :pagerduty_ack_duration => :integer,
+                        :last_rollup_type       => :string
+
+      belongs_to :contact, :class_name => 'Flapjack::Data::Contact',
+        :inverse_of => :media
+
+      has_and_belongs_to_many :rules, :class_name => 'Flapjack::Data::Rule',
+        :inverse_of => :media
+
+      # this can be called from the API (with no args) or from notifier.rb
+      # (which will pass an effective time)
+      def alerting_checks(opts = {})
+        time = opts[:time] || Time.now
+        init_scope = Flapjack::Data::Check.intersect(:enabled => true, :alertable => true)
+        ret = checks(:initial_scope => init_scope,
+                     :time => Time.now)
+
+        return Flapjack::Data::Check.empty if ret.empty?
+
+        start_range = Zermelo::Filters::IndexRange.new(nil, time, :by_score => true)
+        end_range   = Zermelo::Filters::IndexRange.new(time, nil, :by_score => true)
+
+        sched_maint_check_ids = Flapjack::Data::ScheduledMaintenance.
+          intersect(:start_time => start_range, :end_time => end_range).
+          associated_ids_for(:check).values
+
+        ret = ret.diff(:id => sched_maint_check_ids) unless sched_maint_check_ids.empty?
+
+        unsched_maint_check_ids = Flapjack::Data::UnscheduledMaintenance.
+          intersect(:start_time => start_range, :end_time => end_range).
+          associated_ids_for(:check).values
+
+        ret = ret.diff(:id => unsched_maint_check_ids) unless unsched_maint_check_ids.empty?
+        ret
+      end
+
+      def checks(opts = {})
+        time_zone = self.contact.time_zone
+        time = opts[:time] || Time.now
+        init_scope = opts[:initial_scope] || Flapjack::Data::Check.intersect(:enabled => true)
+
+        # TODO maybe fold time validation into 'matching_checks'
+        global_rejector_ids = self.rules.intersect(:enabled => true, :blackhole => true,
+          :strategy => 'global').select {|rejector|
+
+          rejector.is_occurring_at?(time, time_zone)
+        }.map(&:id)
+
+        unless global_rejector_ids.empty?
+          # global blackhole
+          return Flapjack::Data::Check.empty
+        end
+
+        rejector_ids = self.rules.intersect(:enabled => true, :blackhole => true,
+          :strategy => ['all_tags', 'any_tag', 'no_tag']).select {|rejector|
+
+          rejector.is_occurring_at?(time, time_zone)
+        }.map(&:id)
+
+        acceptors = self.rules.intersect(:enabled => true, :blackhole => false).select {|acceptor|
+          acceptor.is_occurring_at?(time, time_zone)
+        }
+
+        # no positives
+        return Flapjack::Data::Check.empty if acceptors.empty?
+
+        ret = init_scope
+
+        if acceptors.none? {|a| 'global'.eql?(a.strategy) }
+          # if no global acceptor, scope by tags for acceptors
+          acceptor_checks = Flapjack::Data::Rule.matching_checks(acceptors.map(&:id))
+          ret = ret.intersect(:id => acceptor_checks)
+        end
+
+        # then exclude by checks with tags matching rejector, if any
+        rejector_checks = Flapjack::Data::Rule.matching_checks(rejector_ids)
+        unless rejector_checks.empty?
+          ret = ret.diff(:id => rejector_checks)
+        end
+
+        ret
+      end
+
+      has_many :alerts, :class_name => 'Flapjack::Data::Alert', :inverse_of => :medium
+
+      belongs_to :last_state, :class_name => 'Flapjack::Data::State',
+        :inverse_of => :latest_media, :after_clear => :destroy_state
+
+      def self.destroy_state(medium_id, st_id)
+        # won't be deleted if still referenced elsewhere -- see the State
+        # before_destroy callback
+        Flapjack::Data::State.intersect(:id => st_id).destroy_all
+      end
+
+      index_by :transport
+
+      validates :transport, :presence => true,
+        :inclusion => {:in => Flapjack::Data::Medium::TRANSPORTS }
+
+      validates :address, :presence => true
+
+      validates :interval, :presence => true,
+        :numericality => {:greater_than_or_equal_to => 0, :only_integer => true},
+        :unless => proc {|m| 'pagerduty'.eql?(m.transport) }
+
+      validates :rollup_threshold, :allow_nil => true,
+        :numericality => {:greater_than => 0, :only_integer => true},
+        :unless => proc {|m| 'pagerduty'.eql?(m.transport) }
+
+      validates_each :interval, :rollup_threshold,
+        :if =>  proc {|m| 'pagerduty'.eql?(m.transport) } do |record, att, value|
+
+        record.errors.add(att, 'must be nil') unless value.nil?
+      end
+
+      validates :pagerduty_subdomain, :presence => true,
+        :if => proc {|m| 'pagerduty'.eql?(m.transport) }
+
+      validates :pagerduty_token, :presence => true,
+        :if => proc {|m| 'pagerduty'.eql?(m.transport) }
+
+      validates :pagerduty_ack_duration, :allow_nil => true,
+        :numericality => {:greater_than => 0, :only_integer => true},
+        :if => proc {|m| 'pagerduty'.eql?(m.transport) }
+
+      validates_each :pagerduty_subdomain, :pagerduty_token,
+        :pagerduty_ack_duration,
+        :unless =>  proc {|m| 'pagerduty'.eql?(m.transport) } do |record, att, value|
+        record.errors.add(att, 'must be nil') unless value.nil?
+      end
+
+      validates_with Flapjack::Data::Validators::IdValidator
+
+      swagger_schema :Medium do
+        key :required, [:id, :type, :transport]
+
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::Medium.short_model_name.singular]
+        end
+        property :transport do
+          key :type, :string
+          key :enum, Flapjack::Data::Medium::TRANSPORTS.map(&:to_sym)
+        end
+        property :address do
+          key :type, :string
+        end
+        property :interval do
+          key :type, :integer
+          key :minimum, 0
+        end
+        property :rollup_threshold do
+          key :type, :integer
+          key :minimum, 1
+        end
+        property :pagerduty_subdomain do
+          key :type, :string
+        end
+        property :pagerduty_token do
+          key :type, :string
+        end
+        property :pagerduty_ack_duration do
+          key :type, :integer
+          key :minimum, 1
+        end
+        property :relationships do
+          key :"$ref", :MediumLinks
+        end
+      end
+
+      swagger_schema :MediumLinks do
+        key :required, [:contact, :rules]
+        property :contact do
+          key :"$ref", :ContactLinkage
+        end
+        property :rules do
+          key :"$ref", :RulesLinkage
+        end
+      end
+
+      swagger_schema :MediumCreate do
+        key :required, [:type, :address, :transport]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::Medium.short_model_name.singular]
+        end
+        property :transport do
+          key :type, :string
+          key :enum, Flapjack::Data::Medium::TRANSPORTS.map(&:to_sym)
+        end
+        property :address do
+          key :type, :string
+        end
+        property :interval do
+          key :type, :integer
+          key :minimum, 0
+        end
+        property :rollup_threshold do
+          key :type, :integer
+          key :minimum, 1
+        end
+        property :pagerduty_subdomain do
+          key :type, :string
+        end
+        property :pagerduty_token do
+          key :type, :string
+        end
+        property :pagerduty_ack_duration do
+          key :type, :integer
+          key :minimum, 1
+        end
+        property :relationships do
+          key :"$ref", :MediumCreateLinks
+        end
+      end
+
+      swagger_schema :MediumCreateLinks do
+        key :required, [:contact]
+        property :contact do
+          key :"$ref", :data_ContactReference
+        end
+        property :rules do
+          key :"$ref", :data_RulesReference
+        end
+      end
+
+      swagger_schema :MediumUpdate 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::Medium.short_model_name.singular]
+        end
+        property :transport do
+          key :type, :string
+          key :enum, Flapjack::Data::Medium::TRANSPORTS.map(&:to_sym)
+        end
+        property :address do
+          key :type, :string
+        end
+        property :interval do
+          key :type, :integer
+          key :minimum, 0
+        end
+        property :rollup_threshold do
+          key :type, :integer
+          key :minimum, 1
+        end
+        property :pagerduty_subdomain do
+          key :type, :string
+        end
+        property :pagerduty_token do
+          key :type, :string
+        end
+        property :pagerduty_ack_duration do
+          key :type, :integer
+          key :minimum, 1
+        end
+        property :relationships do
+          key :"$ref", :MediumUpdateLinks
+        end
+      end
+
+      swagger_schema :MediumUpdateLinks do
+        property :rules do
+          key :"$ref", :data_RulesReference
+        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 => [:transport, :address, :interval, :rollup_threshold,
+                            :pagerduty_subdomain, :pagerduty_token,
+                            :pagerduty_ack_duration],
+            :descriptions => {
+              :singular => "Create a media record.",
+              :multiple => "Create media records."
+            }
+          ),
+          :get => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:transport, :address, :interval, :rollup_threshold,
+                            :pagerduty_subdomain, :pagerduty_token,
+                            :pagerduty_ack_duration],
+            :descriptions => {
+              :singular => "Returns data for a media record.",
+              :multiple => "Returns data for media records."
+            }
+          ),
+          :patch => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:transport, :address, :interval, :rollup_threshold,
+                            :pagerduty_subdomain, :pagerduty_token,
+                            :pagerduty_ack_duration],
+            :descriptions => {
+              :singular => "Update a media record.",
+              :multiple => "Update media records."
+            }
+          ),
+          :delete => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :descriptions => {
+              :singular => "Delete a media record.",
+              :multiple => "Delete media records."
+            }
+          )
+        }
+      end
+
+      def self.jsonapi_associations
+        unless instance_variable_defined?('@jsonapi_associations')
+          @jsonapi_associations = {
+            :alerting_checks => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :get => true,
+              :number => :multiple, :link => true, :includable => true,
+              :type => 'check',
+              :klass => Flapjack::Data::Check,
+              :callback_classes => [
+                Flapjack::Data::Contact,
+                Flapjack::Data::Rule,
+                Flapjack::Data::ScheduledMaintenance
+              ],
+              :descriptions => {
+                :get => "Returns all checks that have alerted through a medium (that are still failing."
+              }
+            ),
+            :contact => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true, :get => true,
+              :number => :singular, :link => true, :includable => true,
+              :descriptions => {
+                :post => "Set a contact for a medium during medium creation (required).",
+                :get => "Get the contact a medium belongs to."
+              }
+            ),
+            :rules => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true, :get => true, :patch => true, :delete => true,
+              :number => :multiple, :link => true, :includable => true,
+              :descriptions => {
+                :post => "Associate this medium with rules on medium creation.",
+                :get => "Get the rules this medium is associated with.",
+                :patch => "Update the rules this medium is associated with.",
+                :delete => "Delete associations between this medium and rules."
+              }
+
+            )
+          }
+          populate_association_data(@jsonapi_associations)
+        end
+        @jsonapi_associations
+      end
+    end
+  end
+end