flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/data/semaphore.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'securerandom'
-
-module Flapjack
-  module Data
-
-    # http://redis.io/commands/set
-    class Semaphore
-
-      SEMAPHORE_KEYSPACE = 'semaphores:'
-
-      attr_reader :token, :expiry, :resource
-
-      class ResourceLocked < RuntimeError
-      end
-
-      def initialize(resource, options)
-        raise "redis connection must be passed in options" unless @redis = options[:redis]
-        @resource = resource
-        @token    = options[:token]  || SecureRandom.uuid
-        @expiry   = options[:expiry] || 30
-
-        @key = "#{SEMAPHORE_KEYSPACE}#{@resource}"
-
-        raise Flapjack::Data::Semaphore::ResourceLocked.new unless @redis.set(@key, @token, {:nx => true, :ex => @expiry})
-      end
-
-      def release
-        unlock_script = '
-         if redis.call("get",KEYS[1]) == ARGV[1]
-          then
-            return redis.call("del",KEYS[1])
-          else
-            return 0
-          end
-        '
-        @redis.eval(unlock_script, [@key], [@token])
-      end
-
-    end
-  end
-end
-

data/lib/flapjack/data/tagged.rb

@@ -1,48 +0,0 @@
-#!/usr/bin/env ruby
-
-# mixed in to some of the Flapjack data classes
-
-module Flapjack
-
-  module Tagged
-
-    def tag_prefix
-      self.class.name.split('::').last.downcase + '_tag'
-    end
-
-    def known_key
-      "known_tags:#{tag_prefix}"
-    end
-
-    # return the set of tags for this object
-    def tags
-      return @tags unless @tags.nil?
-      @tags ||= Set.new( @redis.smembers(known_key).inject([]) {|memo, t|
-        tag_key = "#{tag_prefix}:#{t}"
-        memo << t if @redis.sismember(tag_key, @id.to_s)
-        memo
-      })
-    end
-
-    # adds tags to this object
-    def add_tags(*enum)
-      enum.each do |t|
-        @redis.sadd(known_key, t)
-        @redis.sadd("#{tag_prefix}:#{t}", @id)
-        tags.add(t)
-      end
-    end
-
-    # removes tags from this object
-    def delete_tags(*enum)
-      enum.each do |t|
-        tag_key = "#{tag_prefix}:#{t}"
-        @redis.srem(tag_key, @id)
-        tags.delete(t)
-        @redis.srem(known_key, t) if (@redis.scard(tag_key) == 0)
-      end
-    end
-
-  end
-
-end

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

@@ -1,206 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'sinatra/base'
-
-require 'flapjack/data/event'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      module CheckMethods
-
-        module Helpers
-
-          def checks_for_check_names(check_names)
-            return if check_names.nil?
-            entity_cache = {}
-            check_names.inject([]) do |memo, check_name|
-              entity_name, check = check_name.split(':', 2)
-              entity = (entity_cache[entity_name] ||= find_entity(entity_name))
-              memo << find_entity_check(entity, check)
-              memo
-            end
-          end
-
-        end
-
-        def self.registered(app)
-          app.helpers Flapjack::Gateways::JSONAPI::Helpers
-          app.helpers Flapjack::Gateways::JSONAPI::CheckMethods::Helpers
-
-          app.get %r{^/checks(?:/)?(.+)?$} do
-            requested_checks = if params[:captures] && params[:captures][0]
-              params[:captures][0].split(',').uniq
-            else
-              nil
-            end
-
-            checks = if requested_checks
-              requested_checks.collect do|req_check|
-                Flapjack::Data::EntityCheck.for_event_id(req_check, :logger => logger, :redis => redis)
-              end
-            else
-              Flapjack::Data::EntityCheck.all(:logger => logger, :redis => redis)
-            end
-            checks.compact!
-
-            if requested_checks && checks.empty?
-              raise Flapjack::Gateways::JSONAPI::EntityChecksNotFound.new(requested_checks)
-            end
-
-            check_ids = checks.collect {|c| "#{c.entity.name}:#{c.check}" }
-
-            enabled_ids = Flapjack::Data::EntityCheck.enabled_for(check_ids, :redis => redis)
-
-            linked_entity_ids = checks.empty? ? [] : checks.inject({}) do |memo, check|
-              entity = check.entity
-              memo["#{entity.name}:#{check.check}"] = [entity.id]
-              memo
-            end
-
-            checks_json = checks.collect {|check|
-              check_name = "#{check.entity.name}:#{check.check}"
-              check.to_jsonapi(:enabled    => enabled_ids.include?(check_name),
-                               :entity_ids => linked_entity_ids[check_name])
-            }.join(",")
-
-            '{"checks":[' + checks_json + ']}'
-          end
-
-          app.post '/checks' do
-            checks = wrapped_params('checks')
-
-            check_names = checks.collect{|check_data|
-              check = Flapjack::Data::EntityCheck.add(check_data, :redis => redis)
-              "#{check.entity.name}:#{check.check}"
-            }
-
-            response.headers['Location'] = "#{request.base_url}/checks/#{check_names.join(',')}"
-            status 201
-            Flapjack.dump_json(check_names)
-          end
-
-          app.patch %r{^/checks/(.+)$} do
-            checks_for_check_names(params[:captures][0].split(',')).each do |check|
-              apply_json_patch('checks') do |op, property, linked, value|
-                case op
-                when 'replace'
-                  case property
-                  when 'enabled'
-                    # explicitly checking for true/false being passed in
-                    case value
-                    when TrueClass
-                      check.enable!
-                    when FalseClass
-                      check.disable!
-                    end
-                  end
-                when 'add'
-                  case linked
-                  when 'tags'
-                    value.respond_to?(:each) ? check.add_tags(*value) :
-                                               check.add_tags(value)
-                  end
-                when 'remove'
-                  case linked
-                  when 'tags'
-                    value.respond_to?(:each) ? check.delete_tags(*value) :
-                                               check.delete_tags(value)
-                  end
-                end
-              end
-            end
-
-            status 204
-          end
-
-          # create a scheduled maintenance period for a check on an entity
-          app.post %r{^/scheduled_maintenances/checks/(.+)$} do
-            scheduled_maintenances = wrapped_params('scheduled_maintenances')
-            checks_for_check_names(params[:captures][0].split(',')).each do |check|
-              scheduled_maintenances.each do |wp|
-                start_time = validate_and_parsetime(wp['start_time'])
-                halt( err(403, "start time must be provided") ) unless start_time
-
-                check.create_scheduled_maintenance(start_time,
-                  wp[:duration].to_i, :summary => wp[:summary])
-              end
-            end
-
-            status 204
-          end
-
-          # create an acknowledgement for a service on an entity
-          # NB currently, this does not acknowledge a specific failure event, just
-          # the entity-check as a whole
-          app.post %r{^/unscheduled_maintenances/checks/(.+)$} do
-            unscheduled_maintenances = wrapped_params('unscheduled_maintenances', false)
-            checks_for_check_names(params[:captures][0].split(',')).each do |check|
-              unscheduled_maintenances.each do |wp|
-                dur = wp['duration'] ? wp['duration'].to_i : nil
-                duration = (dur.nil? || (dur <= 0)) ? (4 * 60 * 60) : dur
-                summary = wp['summary']
-
-                opts = {:duration => duration}
-                opts[:summary] = summary if summary
-
-                Flapjack::Data::Event.create_acknowledgement(
-                  check.entity_name, check.check, {:redis => redis}.merge(opts))
-              end
-            end
-
-            status 204
-          end
-
-          app.patch %r{^/unscheduled_maintenances/checks/(.+)$} do
-            checks_for_check_names(params[:captures][0].split(',')).each do |check|
-              apply_json_patch('unscheduled_maintenances') do |op, property, linked, value|
-                case op
-                when 'replace'
-                  if ['end_time'].include?(property)
-                    end_time = validate_and_parsetime(value)
-                    check.end_unscheduled_maintenance(end_time.to_i)
-                  end
-                end
-              end
-            end
-            status 204
-          end
-
-          app.delete %r{^/scheduled_maintenances/checks/(.+)$} do
-            start_time = validate_and_parsetime(params[:start_time])
-            halt( err(403, "start time must be provided") ) unless start_time
-
-            checks_for_check_names(params[:captures][0].split(',')).each do |check|
-              check.end_scheduled_maintenance(start_time.to_i)
-            end
-            status 204
-          end
-
-          app.post %r{^/test_notifications/checks/(.+)$} do
-            test_notifications = wrapped_params('test_notifications', false)
-            checks_for_check_names(params[:captures][0].split(',')).each do |check|
-              test_notifications.each do |wp|
-                summary = wp['summary'] ||
-                          "Testing notifications to all contacts interested in entity #{check.entity.name}"
-                Flapjack::Data::Event.test_notifications(
-                  check.entity_name, check.check,
-                  :summary => summary,
-                  :redis => redis)
-              end
-            end
-            status 204
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,221 +0,0 @@
-#!/usr/bin/env ruby
-
-# Formats entity/check data for presentation by the API methods in Flapjack::Gateways::API.
-
-require 'sinatra/base'
-
-require 'flapjack/data/entity_check'
-
-module Flapjack
-
-  module Gateways
-
-    class JSONAPI < Sinatra::Base
-
-      class CheckPresenter
-
-        def initialize(entity_check)
-          @entity_check = entity_check
-        end
-
-        def status
-          {'name'                              => @entity_check.check,
-           'state'                             => @entity_check.state,
-           'enabled'                           => @entity_check.enabled?,
-           'summary'                           => @entity_check.summary,
-           'details'                           => @entity_check.details,
-           'perfdata'                          => @entity_check.perfdata,
-           'in_unscheduled_maintenance'        => @entity_check.in_unscheduled_maintenance?,
-           'in_scheduled_maintenance'          => @entity_check.in_scheduled_maintenance?,
-           'initial_failure_delay'             => @entity_check.initial_failure_delay,
-           'repeat_failure_delay'              => @entity_check.repeat_failure_delay,
-           'last_update'                       => @entity_check.last_update,
-           'last_change'                       => @entity_check.last_change,
-           'last_problem_notification'         => @entity_check.last_notification_for_state(:problem)[:timestamp],
-           'last_recovery_notification'        => @entity_check.last_notification_for_state(:recovery)[:timestamp],
-           'last_acknowledgement_notification' => @entity_check.last_notification_for_state(:acknowledgement)[:timestamp]}
-        end
-
-        def outage(start_time, end_time, options = {})
-          # hist_states is an array of hashes, with [state, timestamp, summary] keys
-          hist_states = @entity_check.historical_states(start_time, end_time)
-          return {:outages => []} if hist_states.empty?
-
-          initial = @entity_check.historical_state_before(hist_states.first[:timestamp])
-          hist_states.unshift(initial) if initial
-
-          # TODO the following works, but isn't the neatest
-          num_states = hist_states.size
-
-          index = 0
-          result = []
-          obj = nil
-
-          while index < num_states do
-            last_obj = obj
-            obj = hist_states[index]
-            index += 1
-
-            next if obj[:state] == 'ok'
-
-            if last_obj && (last_obj[:state] == obj[:state])
-              # TODO maybe build up arrays of these instead, and leave calling
-              # classes to join them together if needed?
-              result.last[:summary] << " / #{obj[:summary]}"
-              result.last[:details] << " / #{obj[:details]}"
-              next
-            end
-
-            ts = obj[:timestamp]
-
-            obj_st  = (last_obj || !start_time) ? ts : [ts, start_time].max
-
-            next_ts_obj = hist_states[index..-1].detect {|hs| hs[:state] != obj[:state] }
-            obj_et  = next_ts_obj ? next_ts_obj[:timestamp] : end_time
-
-            obj_dur = obj_et ? obj_et - obj_st : nil
-
-            result << {:state      => obj[:state],
-                       :start_time => obj_st,
-                       :end_time   => obj_et,
-                       :duration   => obj_dur,
-                       :summary    => obj[:summary] || '',
-                       :details    => obj[:details] || ''
-                      }
-          end
-
-          {:outages => result}
-        end
-
-        def unscheduled_maintenance(start_time, end_time)
-          # unsched_maintenance is an array of hashes, with [duration, timestamp, summary] keys
-          unsched_maintenance = @entity_check.maintenances(start_time, end_time,
-            :scheduled => false)
-
-          # to see if we start in an unscheduled maintenance period, we must check all unscheduled
-          # maintenances before the period and their durations
-          start_in_unsched = start_time.nil? ? [] :
-            @entity_check.maintenances(nil, start_time, :scheduled => false).select {|pu|
-              pu[:end_time] >= start_time
-            }
-
-          {:unscheduled_maintenances => (start_in_unsched + unsched_maintenance)}
-        end
-
-        def scheduled_maintenance(start_time, end_time)
-          # sched_maintenance is an array of hashes, with [duration, timestamp, summary] keys
-          sched_maintenance = @entity_check.maintenances(start_time, end_time,
-            :scheduled => true)
-
-          # to see if we start in a scheduled maintenance period, we must check all scheduled
-          # maintenances before the period and their durations
-          start_in_sched = start_time.nil? ? [] :
-            @entity_check.maintenances(nil, start_time, :scheduled => true).select {|ps|
-              ps[:end_time] >= start_time
-            }
-
-          {:scheduled_maintenances => (start_in_sched + sched_maintenance)}
-        end
-
-        # TODO test whether the below overlapping logic is prone to off-by-one
-        # errors; the numbers may line up more neatly if we consider outages to
-        # start one second after the maintenance period ends.
-        #
-        # TODO test performance with larger data sets
-        def downtime(start_time, end_time)
-          outs = outage(start_time, end_time)[:outages]
-
-          total_secs  = {}
-          percentages = {}
-
-          outs.collect {|obj| obj[:state]}.uniq.each do |st|
-            total_secs[st]  = 0
-            percentages[st] = (start_time.nil? || end_time.nil?) ? nil : 0
-          end
-
-          unless outs.empty?
-
-            # Initially we need to check for cases where a scheduled
-            # maintenance period is fully covered by an outage period.
-            # We then create two new outage periods to cover the time around
-            # the scheduled maintenance period, and remove the original.
-
-            sched_maintenances = scheduled_maintenance(start_time, end_time)[:scheduled_maintenances]
-
-            sched_maintenances.each do |sm|
-
-              split_outs = []
-
-              outs.each { |o|
-                next unless o[:end_time] && (o[:start_time] < sm[:start_time]) &&
-                  (o[:end_time] > sm[:end_time])
-                o[:delete] = true
-                split_outs += [{:state => o[:state],
-                                :start_time => o[:start_time],
-                                :end_time => sm[:start_time],
-                                :duration => sm[:start_time] - o[:start_time],
-                                :summary => "#{o[:summary]} [split start]"},
-                               {:state => o[:state],
-                                :start_time => sm[:end_time],
-                                :end_time => o[:end_time],
-                                :duration => o[:end_time] - sm[:end_time],
-                                :summary => "#{o[:summary]} [split finish]"}]
-              }
-
-              outs.reject! {|o| o[:delete]}
-              outs += split_outs
-              # not strictly necessary to keep the data sorted, but
-              # will make more sense while debgging
-              outs.sort! {|a,b| a[:start_time] <=> b[:start_time]}
-            end
-
-            sched_maintenances.each do |sm|
-
-              outs.each do |o|
-                next unless o[:end_time] && (sm[:start_time] < o[:end_time]) &&
-                  (sm[:end_time] > o[:start_time])
-
-                if sm[:start_time] <= o[:start_time] &&
-                  sm[:end_time] >= o[:end_time]
-
-                  # outage is fully overlapped by the scheduled maintenance
-                  o[:delete] = true
-
-                elsif sm[:start_time] <= o[:start_time]
-                  # partially overlapping on the earlier side
-                  o[:start_time] = sm[:end_time]
-                  o[:duration] = o[:end_time] - o[:start_time]
-                elsif sm[:end_time] >= o[:end_time]
-                  # partially overlapping on the later side
-                  o[:end_time] = sm[:start_time]
-                  o[:duration] = o[:end_time] - o[:start_time]
-                end
-              end
-
-              outs.reject! {|o| o[:delete]}
-            end
-
-            total_secs = outs.inject(total_secs) {|ret, o|
-              ret[o[:state]] += o[:duration] if o[:duration]
-              ret
-            }
-
-            unless (start_time.nil? || end_time.nil?)
-              total_secs.each_pair do |st, ts|
-                percentages[st] = (total_secs[st] * 100.0) / (end_time.to_f - start_time.to_f)
-              end
-              total_secs['ok'] = (end_time - start_time) - total_secs.values.reduce(:+)
-              percentages['ok'] = 100 - percentages.values.reduce(:+)
-            end
-          end
-
-          {:total_seconds => total_secs, :percentages => percentages, :downtime => outs}
-        end
-
-      end
-
-    end
-
-  end
-
-end