flapjack 0.8.10 → 0.8.11

data/lib/flapjack/gateways/jsonapi/notification_rule_methods.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+require 'flapjack/data/contact'
+require 'flapjack/data/notification_rule'
+
+module Flapjack
+
+  module Gateways
+
+    class JSONAPI < Sinatra::Base
+
+      module NotificationRuleMethods
+
+        # module Helpers
+        # end
+
+        def self.registered(app)
+          app.helpers Flapjack::Gateways::JSONAPI::Helpers
+          # app.helpers Flapjack::Gateways::JSONAPI::NotificationRuleMethods::Helpers
+
+          # Creates a notification rule or rules for a contact
+          app.post '/contacts/:contact_id/notification_rules' do
+            rules_data = params[:notification_rules]
+
+            if rules_data.nil? || !rules_data.is_a?(Enumerable)
+              halt err(422, "No valid notification rules were submitted")
+            end
+
+            contact = find_contact(params[:contact_id])
+
+            errors = []
+            rules_data.each do |rule_data|
+              errors << Flapjack::Data::NotificationRule.prevalidate_data(symbolize(rule_data), {:logger => logger})
+            end
+            errors.compact!
+
+            unless errors.nil? || errors.empty?
+              halt err(422, *errors)
+            end
+
+            rules = []
+            errors = []
+            rules_data.each do |rule_data|
+              rule_data = symbolize(rule_data)
+              rule_or_errors = contact.add_notification_rule(rule_data, :logger => logger)
+              if rule_or_errors.respond_to?(:critical_media)
+                rules << rule_or_errors
+              else
+                errors << rule_or_errors
+              end
+            end
+
+            if rules.empty?
+              halt err(422, *errors)
+            else
+              if errors.empty?
+                status 201
+              else
+                logger.warn("Errors during bulk notification rules creation: " + errors.join(', '))
+                status 200
+              end
+            end
+
+            ids = rules.map {|r| r.id}
+            location(ids)
+
+            rules_json = rules.map {|r| r.to_json}.join(',')
+            '{"notification_rules":[' + rules_json + ']}'
+          end
+
+          # get one or more notification rules
+          app.get '/notification_rules/:id' do
+            rules_json = params[:id].split(',').collect {|rule_id|
+              find_rule(rule_id).to_jsonapi
+            }.join(', ')
+
+            '{"notification_rules":[' + rules_json + ']}'
+          end
+
+          app.patch '/notification_rules/:id' do
+            params[:id].split(',').collect {|rule_id|
+              find_rule(rule_id)
+            }.each do |rule|
+              apply_json_patch('notification_rules') do |op, property, linked, value|
+                case op
+                when 'replace'
+                  case property
+                  when 'entities', 'regex_entities', 'tags', 'regex_tags',
+                    'time_restrictions', 'unknown_media', 'warning_media',
+                    'critical_media', 'unknown_blackhole', 'warning_blackhole',
+                    'critical_blackhole'
+
+                    rule.update({property.to_sym => value}, :logger => logger)
+                  end
+                end
+              end
+            end
+
+            status 204
+          end
+
+          # Deletes one or more notification rules
+          app.delete '/notification_rules/:id' do
+            params[:id].split(',').each do |rule_id|
+              rule = find_rule(rule_id)
+              logger.debug("rule to delete: #{rule.inspect}, contact_id: #{rule.contact_id}")
+              contact = find_contact(rule.contact_id)
+              contact.delete_notification_rule(rule)
+            end
+
+            status 204
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/flapjack/gateways/jsonapi/pagerduty_credential_methods.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+require 'flapjack/data/contact'
+
+module Flapjack
+
+  module Gateways
+
+    class JSONAPI < Sinatra::Base
+
+      module PagerdutyCredentialMethods
+
+        SEMAPHORE_CONTACT_MASS_UPDATE = 'contact_mass_update'
+
+        # module Helpers
+        # end
+
+        def self.registered(app)
+          app.helpers Flapjack::Gateways::JSONAPI::Helpers
+          # app.helpers Flapjack::Gateways::JSONAPI::PagerdutyCredentialMethods::Helpers
+
+          # Creates/overwrites pagerduty credentials for a contact
+          app.post '/contacts/:contact_id/pagerduty_credentials' do
+
+            pagerduty_credentials_data = params[:pagerduty_credentials]
+
+            if pagerduty_credentials_data.nil? || !pagerduty_credentials_data.is_a?(Enumerable)
+              halt err(422, "No valid pagerduty credentials were submitted")
+            end
+
+            fields = ['service_key', 'subdomain', 'username', 'password']
+
+            pagerduty_credential = pagerduty_credentials_data.last
+
+            if pagerduty_credential.nil? || !pagerduty_credential.is_a?(Hash)
+              halt err(422, "No valid pagerduty credentials were submitted")
+            end
+
+            if (fields | pagerduty_credential.keys).size != fields.size
+              halt err(422, "Pagerduty credential data has incorrect fields")
+            end
+
+            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
+            contact = Flapjack::Data::Contact.find_by_id(params[:contact_id], :redis => redis)
+            if contact.nil?
+              semaphore.release
+              halt err(422, "Contact id '#{params[:contact_id]}' could not be loaded")
+            end
+
+            pagerduty_credential_data = fields.inject({}) do |memo, field|
+              memo[field] = pagerduty_credential[field]
+              memo
+            end
+
+            contact.set_pagerduty_credentials(pagerduty_credential_data)
+            semaphore.release
+
+            pagerduty_credential_data['links'] = {'contacts' => [contact.id]}
+
+            status 201
+            '{"pagerduty_credentials":[' + pagerduty_credential_data.to_json + ']}'
+          end
+
+          app.get %r{^/pagerduty_credentials(?:/)?([^/]+)?$} do
+            contacts = if params[:captures] && params[:captures][0]
+              params[:captures][0].split(',').uniq.collect {|c_id| find_contact(c_id)}
+            else
+              Flapjack::Data::Contact.all(:redis => redis)
+            end
+
+            pagerduty_credentials_data = contacts.inject([]) do |memo, contact|
+              pdc = contact.pagerduty_credentials.clone
+
+              pdc['links'] = {'contacts' => [contact.id]}
+              memo << pdc
+              memo
+            end
+
+            '{"pagerduty_credentials":' + pagerduty_credentials_data.to_json + '}'
+          end
+
+          # update one or more sets of pagerduty credentials
+          app.patch '/pagerduty_credentials/:contact_id' do
+            params[:contact_id].split(',').uniq.collect {|c_id| find_contact(c_id)}.each do |contact|
+              apply_json_patch('pagerduty_credentials') do |op, property, linked, value|
+                if 'replace'.eql?(op)
+
+                  pdc = contact.pagerduty_credentials.clone
+
+                  case property
+                  when 'service_key'
+                    pdc['service_key'] = value
+                    contact.set_pagerduty_credentials(pdc)
+                  when 'subdomain'
+                    pdc['subdomain'] = value
+                    contact.set_pagerduty_credentials(pdc)
+                  when 'username'
+                    pdc['username'] = value
+                    contact.set_pagerduty_credentials(pdc)
+                  when 'password'
+                    pdc['password'] = value
+                    contact.set_pagerduty_credentials(pdc)
+                  end
+                end
+              end
+            end
+
+            status 204
+          end
+
+          app.delete '/pagerduty_credentials/:contact_id' do
+            params[:contact_id].split(',').uniq.collect {|c_id| find_contact(c_id) }.each do |contact|
+              contact.delete_pagerduty_credentials
+            end
+            status 204
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/flapjack/gateways/jsonapi/rack/json_params_parser.rb

@@ -9,12 +9,11 @@ module Flapjack
         class JsonParamsParser < Struct.new(:app)
           def call(env)
             t = type(env)
-            if env['rack.input'] and not input_parsed?(env) and type_match?(t)
+            if 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 = Oj.load(json_data)
+              data = json_data.empty? ? {} : Oj.load(json_data)
               env['rack.request.form_hash'] = data.empty? ? {} :
                 (('application/json-patch+json'.eql?(t)) ? {'ops' => data} : data)
             end
@@ -26,8 +25,8 @@ module Flapjack
           end
 
           def type(env)
-            return unless env['CONTENT_TYPE']
-            env['CONTENT_TYPE'].split(/\s*[;,]\s*/, 2).first.downcase
+            return if env['CONTENT_TYPE'].nil?
+            env['CONTENT_TYPE'].split(/\s*[;,]\s*/, 2).first
           end
 
           def type_match?(t)

data/lib/flapjack/gateways/jsonapi/report_methods.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+require 'flapjack/data/entity'
+require 'flapjack/data/entity_check'
+
+require 'flapjack/gateways/jsonapi/check_presenter'
+
+module Flapjack
+
+  module Gateways
+
+    class JSONAPI < Sinatra::Base
+
+      module ReportMethods
+
+        module Helpers
+
+          def load_api_data(entity_ids, event_ids, action, &block)
+            result_type = case action
+            when 'status'
+              'statuses'
+            when 'outage'
+              'outages'
+            when 'scheduled_maintenance'
+              'scheduled_maintenances'
+            when 'unscheduled_maintenance'
+              'unscheduled_maintenances'
+            when 'downtime'
+              'downtimes'
+            end
+
+            entities = if entity_ids.nil?
+              Flapjack::Data::Entity.all(:redis => redis)
+            elsif !entity_ids.empty?
+              entity_ids.collect {|entity_id| find_entity_by_id(entity_id) }
+            else
+              nil
+            end
+
+            checks = if event_ids.nil?
+              Flapjack::Data::Entity.all(:redis => redis).collect {|entity|
+                entity.check_list.collect {|check_name|
+                  find_entity_check(entity, check_name)
+                }
+              }.flatten(2)
+            elsif !event_ids.empty?
+              event_ids.collect {|event_id| find_entity_check_by_name(*event_id.split(':', 2)) }
+            else
+              nil
+            end
+
+            entities_by_name             = {}
+            entity_checks_by_entity_name = {}
+
+            (entities || []).each do |entity|
+              entities_by_name[entity.name] = entity
+              check_list_names = entity.check_list
+              entity_checks_by_entity_name[entity.name] = check_list_names.collect {|check_name|
+                find_entity_check_by_name(entity.name, check_name)
+              }
+            end
+
+            (checks || []).each do |check|
+              check_entity = check.entity
+              check_entity_name = check_entity.name
+              entities_by_name[check_entity_name] ||= check_entity
+
+              entity_checks_by_entity_name[check_entity_name] ||= []
+              entity_checks_by_entity_name[check_entity_name] << check
+            end
+
+            entity_data = entities_by_name.inject([]) do |memo, (entity_name, entity)|
+              memo << {
+                'id'    => entity.id,
+                'name'  => entity_name,
+                'links' => {
+                  'checks' => entity_checks_by_entity_name[entity_name].collect {|entity_check|
+                    "#{entity_name}:#{entity_check.check}"
+                  },
+                }
+              }
+              memo
+            end
+
+            entity_check_data = entity_checks_by_entity_name.inject([]) do |memo, (entity_name, entity_checks)|
+              memo += entity_checks.collect do |entity_check|
+                entity_check_name = entity_check.check
+                {
+                  'id'        => "#{entity_name}:#{entity_check_name}",
+                  'name'      => entity_check_name,
+                  result_type => yield(Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check))
+                }
+              end
+              memo
+            end
+
+            [entity_data, entity_check_data]
+          end
+
+        end
+
+        def self.registered(app)
+          app.helpers Flapjack::Gateways::JSONAPI::Helpers
+          app.helpers Flapjack::Gateways::JSONAPI::ReportMethods::Helpers
+
+          app.get %r{^/(status|outage|(?:un)?scheduled_maintenance|downtime)_report/(entities|checks)(?:/([^/]+))?$} do
+            entities_or_checks = params[:captures][1]
+            action = params[:captures][0]
+
+            args = []
+            unless 'status'.eql?(action)
+              args += [validate_and_parsetime(params[:start_time]),
+                       validate_and_parsetime(params[:end_time])]
+            end
+
+            entity_data, check_data = case entities_or_checks
+            when 'entities'
+              entity_ids = params[:captures][2].nil? ? nil : params[:captures][2].split(',')
+              load_api_data(entity_ids, [], action) {|presenter|
+                presenter.send(action, *args)
+              }
+            when 'checks'
+              entity_check_names = params[:captures][2].nil? ? nil : params[:captures][2].split(',')
+              load_api_data([], entity_check_names, action) {|presenter|
+                presenter.send(action, *args)
+              }
+            end
+
+            "{\"#{action}_reports\":" + entity_data.to_json +
+              ",\"linked\":{\"checks\":" + check_data.to_json + "}}"
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/flapjack/gateways/web.rb

@@ -214,6 +214,7 @@ module Flapjack
         @check_last_change          = last_change
         @check_summary              = entity_check.summary
         @check_details              = entity_check.details
+        @check_perfdata             = entity_check.perfdata
 
         @last_notifications         = last_notification_data(entity_check)
 

data/lib/flapjack/gateways/web/public/js/backbone.jsonapi.js

@@ -1,133 +1,197 @@
 
 var toolbox = {};
 
-toolbox.findById = function (array, id) {
-  return _.find(array, function (item) {
-    return item.id === id;
-  });
+toolbox.getMainCollection = function (response) {
+  return _.without(_.keys(response), 'links', 'linked', 'meta')[0];
 };
 
-toolbox.resolveLinks = function(context, obj, linked) {
-  if ( _.isUndefined(obj.links) ) { return; }
+toolbox.batchRequest = function(klass, ids, amount, success) {
+  // batch requests to avoid GET length limits
+  var grouped = _.groupBy(ids, function(element, index){
+    return Math.floor(index/75);
+  });
 
-  _.each(obj.links, function(ids, name) {
-    var linkage_type = context.linkages[name];
+  _.each(grouped, function(ids, index) {
+    var linkedClass = klass.extend({
+      url: function() { return(klass.prototype.url.call() + "/" + ids.join(',')); }
+    });
+    var linkedCollection = new linkedClass();
+    linkedCollection.fetch({'reset' : true, 'success' : success});
+  });
+}
 
-    if ( _.isUndefined(linkage_type) ) {
-      obj.links[name] = null;
-      return;
+toolbox.savePatch = function(model, attrs, patch) {
+  var patch_json = JSON.stringify(patch);
+  return model.save(attrs, {
+    data: patch_json,
+    patch: true,
+    contentType: 'application/json-patch+json'
+  });
+};
+
+Backbone.JSONAPIModel = Backbone.Model.extend({
+
+  resolveLink: function(name, klass, superset) {
+    if ( !_.isUndefined(this.get('links')) && !_.isUndefined(this.get('links')[name]) ) {
+      context = this;
+      var records = superset.filter(function(obj) {
+        return(context.get('links')[name].indexOf(obj.get('id')) > -1);
+      });
+      if ( _.isUndefined(this.get('linked')) ) {
+        this.set('linked', {});
+      }
+      if ( _.isUndefined(this.get('linked')[name]) ) {
+        this.get('linked')[name] = new klass();
+      }
+      this.get('linked')[name].add(records);
     }
+  },
+
+  resolveLinks: function(name_klass_h) {
+    var context = this;
 
-    var linked_for_name = linked[name];
+   _.each(name_klass_h, function(klass, name) {
 
-    if ( _.isUndefined(linked_for_name) ) {
-      if ( _.isArray(ids) ) {
-        obj.links[name] = new linkage_type();
-      } else {
-        obj.links[name] = null;
+      if ( !_.isUndefined(context.get('links')) &&
+           !_.isUndefined(context.get('links')[name]) &&
+           !_.isEmpty(context.get('links')[name]) ) {
+        var success = function(resultCollection, response, options) {
+          context.resolveLink(name, klass, resultCollection);
+        }
+
+        toolbox.batchRequest(klass, context.get('links')[name], 75, success);
       }
+    });
+  },
+
+  parse: function (response) {
+    if (response === undefined) {
       return;
     }
+    if (response._alreadyBBJSONAPIParsed) {
+      delete response._alreadyBBJSONAPIParsed;
+      return response;
+    }
+    var mainCollection = toolbox.getMainCollection(response);
+    var obj = response[mainCollection][0];
 
-    if ( _.isArray(ids) ) {
-      var collection = new linkage_type();
-      collection.add(_.map(ids, function(id) {
-        return new collection.model(toolbox.findById(linked_for_name, id));
-      }));
-      obj.links[name] = collection;
-    } else {
-      obj.links[name] = new linkage_type(toolbox.findById(linked_for_name, ids));
+    return obj;
+  },
+
+  // makes sense to call this with model.patch(model.changedAttributes),
+  // if that value isn't false
+  patch: function(urlType, attrs) {
+    if (attrs == null) {
+      attrs = {};
     }
-  });
 
-};
+    var context = this;
 
-toolbox.getMainCollection = function (response) {
-  return _.without(_.keys(response), 'links', 'linked', 'meta')[0];
-};
+    var patch = _.inject(attrs, function(memo, val, key) {
+      // skip if not a simple attribute value
+      if ( (key == 'links') || _.isObject(val) || _.isArray(val) ) {
+        return memo;
+      }
 
-Backbone.Collection.prototype.parse = function (response) {
-  if (response === undefined) {
-    return;
-  }
-  var mainCollection = toolbox.getMainCollection(response);
-  var context = this;
-  return _.map(response[mainCollection], function (obj) {
-    toolbox.resolveLinks(context, obj, (response['linked'] || {}));
-    obj._alreadyBBJSONAPIParsed = true;
-    return obj;
-  });
-};
+      memo.push({
+        op: 'replace',
+        path: '/' + urlType + '/0/' + key,
+        value: val
+      });
 
-Backbone.Model.prototype.parse = function (response) {
-  if (response === undefined) {
-    return;
-  }
-  if (response._alreadyBBJSONAPIParsed) {
-    delete response._alreadyBBJSONAPIParsed;
-    return response;
+      return memo;
+    }, new Array());
+
+    toolbox.savePatch(this, attrs, patch);
+  },
+
+  // singular operation only -- TODO batch up and submit en masse
+  addLinked: function(urlType, type, obj) {
+    var patch = [{
+      op: 'add',
+      path: '/' + urlType + '/0/links/' + type + '/-',
+      value: obj.get('id')
+    }];
+
+    toolbox.savePatch(this, {}, patch);
+    this.get('linked')[type].add(obj);
+  },
+
+  // singular operation only -- TODO batch up and submit en masse
+  removeLinked: function(urlType, type, obj) {
+    var patch = [{
+      op: 'remove',
+      path: '/' + urlType + '/0/links/' + type + '/' + obj.get('id'),
+    }];
+
+    toolbox.savePatch(this, {}, patch);
+    this.get('linked')[type].remove(obj);
+  },
+
+  sync: function(method, model, options) {
+    if ( method == 'create' ) {
+      options['contentType'] = 'application/vnd.api+json';
+    }
+    Backbone.sync(method, model, options);
   }
-  var mainCollection = toolbox.getMainCollection(response);
-  var obj = response[mainCollection][0];
-  toolbox.resolveLinks(this, obj, (response['linked'] || {}));
-  return obj;
-};
 
-toolbox.savePatch = function(model, attrs, patch) {
-  var patch_json = JSON.stringify(patch);
-  return model.save(attrs, {
-    data: patch_json,
-    patch: true,
-    contentType: 'application/json-patch+json'
-  });
-};
+});
 
-// makes sense to call this with model.patch(model.changedAttributes),
-// if that value isn't false
-Backbone.Model.prototype.patch = function(attrs) {
-  if (attrs == null) {
-    attrs = {};
-  }
 
-  var context = this;
+Backbone.JSONAPICollection = Backbone.Collection.extend({
 
-  var patch = _.inject(attrs, function(memo, val, key) {
-    // skip if not a simple attribute value
-    if ( (key == 'links') || _.isObject(val) || _.isArray(val) ) {
-      return memo;
+  resolveLinks: function(name_klass_h) {
+    if ( _.isUndefined(this.linked) ) {
+      this.linked = {};
     }
 
-    memo.push({
-      op: 'replace',
-      path: '/' + context.urlType + '/0/' + key,
-      value: val
-    });
+    var context = this;
 
-    return memo;
-  }, new Array());
+    _.each(name_klass_h, function(klass, name) {
 
-  toolbox.savePatch(this, attrs, patch);
-};
+      if ( !_.isUndefined(context.links[name]) && !_.isEmpty(context.links[name]) ) {
+        context.linked[name] = new klass();
 
-// singular operation only -- TODO batch up and submit en masse
-Backbone.Model.prototype.addLinked = function(type, obj) {
-  var patch = [{
-    op: 'add',
-    path: '/' + this.urlType + '/0/links/' + type + '/-',
-    value: obj.get('id')
-  }];
+        var success = function(resultCollection, response, options) {
+          context.forEach(function(obj, index) {
+            obj.resolveLink(name, klass, resultCollection);
+          });
+        }
 
-  toolbox.savePatch(this, {}, patch);
-  this.get('links')[type].add(obj);
-};
+        toolbox.batchRequest(klass, context.links[name], 75, success);
+      }
+    });
+  },
 
-// singular operation only -- TODO batch up and submit en masse
-Backbone.Model.prototype.removeLinked = function(type, obj) {
-  var patch = [{
-    op: 'remove',
-    path: '/' + this.urlType + '/0/links/' + type + '/' + obj.get('id'),
-  }];
+  parse: function (response) {
+    if (response === undefined) {
+      return;
+    }
 
-  toolbox.savePatch(this, {}, patch);
-  this.get('links')[type].remove(obj);
-};
+    this.links = {};
+    var context = this;
+
+    var mainCollection = toolbox.getMainCollection(response);
+    var objects = _.map(response[mainCollection], function (obj) {
+      _.each(obj.links, function(ids, name) {
+        if ( _.isUndefined(context.links[name]) ) {
+          context.links[name] = new Array();
+        }
+        if ( _.isArray(ids) ) {
+          context.links[name] = context.links[name].concat(ids);
+        }
+      });
+
+      obj._alreadyBBJSONAPIParsed = true;
+      return obj;
+    });
+
+    this.links = _.reduce(this.links, function(memo, ids, name) {
+      memo[name] = _.uniq(ids);
+      return(memo);
+    }, {});
+
+    return objects;
+  }
+
+});