diff options
26 files changed, 610 insertions, 273 deletions
diff --git a/bin/mauveserver b/bin/mauveserver index b0c3573..cc2b124 100644 --- a/bin/mauveserver +++ b/bin/mauveserver @@ -34,6 +34,8 @@ # Patrick J Cherry <patrick@bytemark.co.uk> # +$:.unshift File.expand_path(File.join(File.dirname(__FILE__),"..","lib")) + help = manual = verbose = version = test = false while arg = ARGV.pop case arg diff --git a/example.conf b/example.conf index 4123d8e..347c33d 100644 --- a/example.conf +++ b/example.conf @@ -5,13 +5,18 @@ server { # # This is where our database lives. SQLite is the default. # - database "sqlite3::memory:" + + # database "sqlite3::memory:" + database "postgres://localhost/mauvealert" # # This is our hostname. It gets used when URLs are generated, and in the heartbeat alert. # hostname "mauve.example.com" +# use_packet_buffer "no" +# use_notification_buffer "no" + # # This is the UDP listener. # @@ -27,7 +32,7 @@ server { # # This is how long the UDP server will sleep between looking for packets. # - poll_every 1 + poll_every 0 } @@ -40,7 +45,7 @@ server { # This is the length of time the processor will sleep between checking for # new packets from the UDP listener. # - poll_every 1 + poll_every 0 # # In order to make sure the same transmission isn't received more then @@ -78,23 +83,23 @@ server { # This is where the mauve server sends its own heartbeat. Useful for # watching the watcher. # - heartbeat { +# heartbeat { # # If no destination is specified, then the contents of # /etc/mauvealert/mauvesend.destination are used. # - destination "localhost" +# destination "localhost" # # This is how long to wait before the alert is raised # - raise_after 600 +# raise_after 600 # # These two fields have sensible defaults set, but more informative # messages can be set here. # - summary "Mauve alert server is down" - detail "The Mauve alert server has failed to send a heartbeat" - } +# summary "Mauve alert server is down" +# detail "The Mauve alert server has failed to send a heartbeat" +# } } @@ -137,7 +142,7 @@ logger { outputter("file") { filename "/tmp/mauveserver.log" trunc true - level Log4r::DEBUG + level Log4r::INFO } # outputter("email") { @@ -154,24 +159,16 @@ logger { # XMPP instant messaging. This are the credentials to log into the XMPP # account that mauve will use. # -#notification_method ("xmpp") { -# jid "mauve@chat.example.com/mauve" -# password "mauvespassword" -#} - -# -# Email messaging. -# -notification_method ("email") { - server "localhost" - from "mauve@desk1.tur.bytemark.co.uk" - subject_prefix "mauve-test" +# XMPP instant messaging. +notification_method ("xmpp") { + jid "bytemark@chat.bytemark.co.uk/pjc-test" + password "OsPzCmqSb" } person("office_chat") { -# xmpp "muc:mauve-test@conference.chat.bytemark.co.uk/MauveAlert" -# all { xmpp } -# suppress_notifications_after(310 => 1.minute) + xmpp "muc:mauve-test@conference.chat.bytemark.co.uk/MauveAlert" + all { xmpp } + suppress_notifications_after(310 => 1.minute) } person ("pcherry") { @@ -179,17 +176,13 @@ person ("pcherry") { all { true } } -people_list ("arse") { - list [ "office_chat" ] -} - # # Default notification - tell root about all alerts every hour # alert_group("default") { level URGENT - notify("arse") { + notify("office_chat") { every 2.minutes } } diff --git a/lib/mauve/alert.rb b/lib/mauve/alert.rb index f249913..6b08f82 100644 --- a/lib/mauve/alert.rb +++ b/lib/mauve/alert.rb @@ -420,7 +420,7 @@ module Mauve # # Limit acknowledgment time. # - limit = Time.now + 15.days + limit = Time.now + Configuration.current.max_acknowledgement_time ack_until = limit if ack_until > limit self.acknowledged_by = person.username diff --git a/lib/mauve/authentication.rb b/lib/mauve/authentication.rb index c467a1d..24c6bd3 100644 --- a/lib/mauve/authentication.rb +++ b/lib/mauve/authentication.rb @@ -70,7 +70,7 @@ module Mauve unless true == result logger.info "Authentication for #{login} failed" # Rate limit - sleep Server.instance.failed_login_delay + sleep Configuration.current.failed_login_delay end result @@ -97,15 +97,15 @@ module Mauve # # Don't bother checking if no auth_url has been set. # - return false unless Server.instance.bytemark_auth_url.is_a?(URI) + return false unless Configuration.current.bytemark_auth_url.is_a?(URI) # # Don't bother checking if the person doesn't exist. # return false unless Mauve::Configuration.current.people.has_key?(login) - uri = Server.instance.bytemark_auth_url - timeout = Server.instance.remote_http_timeout + uri = Configuration.current.bytemark_auth_url + timeout = Configuration.current.remote_http_timeout # host=nil, path=nil, port=nil, proxy_host=nil, proxy_port=nil, user=nil, password=nil, use_ssl=nil, timeout=nil) client = XMLRPC::Client.new(uri.host, uri.path, uri.port, nil, nil, uri.user, uri.password, uri.scheme == "https", timeout) @@ -114,7 +114,7 @@ module Mauve # if client.http.use_ssl? client.http.ca_path = "/etc/ssl/certs/" - client.http.verify_mode = Server.instance.remote_https_verify_mode + client.http.verify_mode = Configuration.current.remote_https_verify_mode end begin diff --git a/lib/mauve/calendar_interface.rb b/lib/mauve/calendar_interface.rb index cf515d1..692981d 100644 --- a/lib/mauve/calendar_interface.rb +++ b/lib/mauve/calendar_interface.rb @@ -17,52 +17,58 @@ module Mauve @logger ||= Log4r::Logger.new(self.to_s) end - # Gets a list of ssologin on support. + def get_attendees(klass, at=Time.now) + # + # Returns nil if no calendar_url has been set. + # + return [] unless Configuration.current.bytemark_calendar_url + + url = Configuration.current.bytemark_calendar_url.dup + + url.merge!(File.join(url.path, "/api/attendees/#{klass}/#{at.strftime("%Y-%m-%dT%H:%M:00")}")) + ans = do_get(url) + + return [] unless ans.is_a?(Array) + + ans.select{|x| x.is_a?(String)} + end + # - # @param [String] url A Calendar API url. + # This should return a list of dates of forthcoming bank holidays # - # @return [Array] A list of all the usernames on support. - def get_users_on_support(url) - result = do_get_with_cache(url) - - if result.is_a?(String) - result = result.split("\n") - else - result = [] - end + def get_bank_holiday_list(at = Time.now) + return [] unless Configuration.current.bytemark_calendar_url - return result + url = Configuration.current.bytemark_calendar_url.dup + url.merge!(File.join(url.path, "/api/bank_holidays/#{at.strftime("%Y-%m-%d")}")) + ans = do_get(url) + + return [] unless ans.is_a?(Array) + ans.select{|x| x.is_a?(Date)} end - # Check to see if the user is on support. + # Check to see if the user is on holiday. # - # @param [String] url A Calendar API url. - # @param [String] usr User single sign on. + # Class method. # - # @return [Boolean] True if on support, false otherwise. - def is_user_on_support?(url, usr) - return get_users_on_support(url).include?(usr) + # @param [String] usr User single sign on. + # + # @return [Boolean] True if on holiday, false otherwise. + def is_user_on_holiday?(usr, at=Time.now) + get_attendees("staff_holiday").include?(usr) end # Check to see if the user is on holiday. # # Class method. # - # @param [String] url A Calendar API url. # @param [String] usr User single sign on. # # @return [Boolean] True if on holiday, false otherwise. - def is_user_on_holiday?(url) - result = do_get_with_cache(url) - - if result.is_a?(String) and result =~ /^\d{4}(-\d\d){2}[ T](\d\d:){2}\d\d/ - return true - else - return false - end + def is_user_off_sick?(usr, at=Time.now) + get_attendees("sick_period", at).include?(usr) end - private # Grab a URL from the wide web. @@ -74,7 +80,7 @@ module Mauve # def do_get (uri, limit = 11) - if 0 == limit + if 0 > limit logger.warn("HTTP redirect too deep for #{uri}.") return nil end @@ -99,8 +105,22 @@ module Mauve response = http.start { http.get(uri.request_uri()) } if response.is_a?(Net::HTTPOK) - return response.body + # + # Parse the string as YAML. + # + result = if response.body.is_a?(String) + begin + YAML.load(response.body) + rescue YAML::Error => err + logger.error "Caught #{ex.class.to_s} (#{ex.to_s}) whilst querying #{url.to_s}." + logger.debug err.backtrace.join("\n") + nil + end + else + nil + end + return result elsif response.is_a?(Net::HTTPRedirection) and response.key?('Location') location = response['Location'] @@ -123,6 +143,7 @@ module Mauve logger.error("Timeout caught during fetch of #{uri.to_s}.") rescue StandardError => ex + pp ex.backtrace logger.error("#{ex.class} caught during fetch of #{uri.to_s}: #{ex.to_s}.") logger.debug(ex.backtrace.join("\n")) @@ -140,10 +161,10 @@ module Mauve def do_get_with_cache(url, cache_until = Time.now + 5.minutes) @cache ||= {} - if @cache.has_key?(url.to_s) - result, cache_until = @cache[url.to_s] + if @cache.has_key?(url) + result, cached_until = @cache[url] - return result if cache_until >= Time.now and not result.nil? + return result if cached_until > Time.now and not result.nil? end result = do_get(url) @@ -152,6 +173,19 @@ module Mauve return result end + # + # This should get called periodically. + # + def clean_cache + + @cache.keys.select do |url| + result, cached_until = @cache[url] + @cache.delete(url) if !cached_until.is_a?(Time) or cached_until <= Time.now + end + + @cache + end + end end diff --git a/lib/mauve/configuration.rb b/lib/mauve/configuration.rb index 65f5f71..3a8f9cc 100644 --- a/lib/mauve/configuration.rb +++ b/lib/mauve/configuration.rb @@ -40,6 +40,12 @@ module Mauve # @return [Hash] attr_reader :source_lists + # Various further configuration items + # + attr_reader :bytemark_auth_url, :bytemark_calendar_url, :remote_http_timeout, :remote_https_verify_mode, :failed_login_delay + attr_reader :max_acknowledgement_time + + # # Set up a base config. # @@ -50,7 +56,114 @@ module Mauve @people_lists = {} @source_lists = Hash.new{|h,k| h[k] = Mauve::SourceList.new(k)} @alert_groups = [] + + # + # Set the auth/calendar URLs + # + @bytemark_auth_url = nil + @bytemark_calendar_url = nil + + # + # Set a couple of params for remote HTTP requests. + # + @remote_http_timeout = 5 + @remote_https_verify_mode = OpenSSL::SSL::VERIFY_PEER + + # + # Rate limit login attempts to limit the success of brute-forcing. + # + @failed_login_delay = 1 + + # + # Maximum amount of time to acknowledge for + # + @max_acknowledgement_time = 15.days + end + + # Set the calendar URL. + # + # @param [String] arg + # @return [URI] + def bytemark_calendar_url=(arg) + raise ArgumentError, "bytemark_calendar_url must be a string" unless arg.is_a?(String) + + @bytemark_calendar_url = URI.parse(arg) + + # + # Make sure we get an HTTP URL. + # + raise ArgumentError, "bytemark_calendar_url must be an HTTP(S) URL." unless %w(http https).include?(@bytemark_calendar_url.scheme) + + # + # Set a default request path, if none was given + # + @bytemark_calendar_url.normalize! + + @bytemark_calendar_url + end + + # Set the Bytemark Authentication URL + # + # @param [String] arg + # @return [URI] + def bytemark_auth_url=(arg) + raise ArgumentError, "bytemark_auth_url must be a string" unless arg.is_a?(String) + + @bytemark_auth_url = URI.parse(arg) + # + # Make sure we get an HTTP URL. + # + raise ArgumentError, "bytemark_auth_url must be an HTTP(S) URL." unless %w(http https).include?(@bytemark_auth_url.scheme) + + # + # Set a default request path, if none was given + # + @bytemark_auth_url.normalize! + + @bytemark_auth_url + end + + # Sets the timeout when making remote HTTP requests + # + # @param [Integer] arg + # @return [Integer] + def remote_http_timeout=(arg) + raise ArgumentError, "remote_http_timeout must be an integer" unless s.is_a?(Integer) + @remote_http_timeout = arg + end + + # Sets the SSL verification mode when makeing remote HTTPS requests + # + # @param [String] arg must be one of "none" or "peer" + # @return [Constant] + def remote_https_verify_mode=(arg) + @remote_https_verify_mode = case arg + when "peer" + OpenSSL::SSL::VERIFY_PEER + when "none" + OpenSSL::SSL::VERIFY_NONE + else + raise ArgumentError, "remote_https_verify_mode must be either 'peer' or 'none'" + end + end + + # Set the delay added following a failed login attempt. + # + # @param [Numeric] arg Number of seconds to delay following a failed login attempt + # @return [Numeric] + # + def failed_login_delay=(arg) + raise ArgumentError, "failed_login_delay must be numeric" unless arg.is_a?(Numeric) + @failed_login_delay = arg end + # Set the maximum amount of time alerts can be ack'd for + # + # + def max_acknowledgement_time=(arg) + raise ArgumentError, "max_acknowledgement_time must be numeric" unless arg.is_a?(Numeric) + @max_acknowledgement_time = arg + end + end end diff --git a/lib/mauve/configuration_builder.rb b/lib/mauve/configuration_builder.rb index 3f7138e..c689c1b 100644 --- a/lib/mauve/configuration_builder.rb +++ b/lib/mauve/configuration_builder.rb @@ -29,18 +29,6 @@ module Mauve @result.source_lists[label] += list end - # Adds a people list - # - # @param [String] label - # @param [Array] list - # - # @return [Array] the whole people list for label - # ef people_list(label, *list) - # _logger.warn("Duplicate people_list '#{label}'") if @result.people_lists.has_key?(label) - # @result.people_lists[label] += list - # end - - # Have to use the method _logger here, cos logger is defined as a builder elsewhere. # # @return [Log4r::Logger] diff --git a/lib/mauve/configuration_builders/notification_method.rb b/lib/mauve/configuration_builders/notification_method.rb index 3f9283e..7951dee 100644 --- a/lib/mauve/configuration_builders/notification_method.rb +++ b/lib/mauve/configuration_builders/notification_method.rb @@ -40,18 +40,6 @@ module Mauve result.extend(Mauve::Notifiers::Debug) end - # This catches all methods available for a provider, as needed. - # - # Missing methods / bad arguments etc. are caught in the - # ObjectBuilder#parse method, via NoMethodError. - # - def method_missing(name, value=nil) - if value - result.send("#{name}=".to_sym, value) - else - result.send(name.to_sym) - end - end end end diff --git a/lib/mauve/configuration_builders/person.rb b/lib/mauve/configuration_builders/person.rb index dff6f85..7a20491 100644 --- a/lib/mauve/configuration_builders/person.rb +++ b/lib/mauve/configuration_builders/person.rb @@ -18,12 +18,14 @@ module Mauve is_block_attribute "urgent" is_block_attribute "normal" is_block_attribute "low" + is_attribute "password" is_attribute "sms" - is_attribute "holiday_url" is_attribute "email" is_attribute "xmpp" - is_attribute "sms" + + is_flag_attribute "notify_when_on_holiday!" + is_flag_attribute "notify_when_off_sick!" # Sets the block for all levels of alert # diff --git a/lib/mauve/configuration_builders/server.rb b/lib/mauve/configuration_builders/server.rb index d22ed87..734fb3b 100644 --- a/lib/mauve/configuration_builders/server.rb +++ b/lib/mauve/configuration_builders/server.rb @@ -171,31 +171,6 @@ module Mauve is_attribute "use_packet_buffer" is_attribute "use_notification_buffer" - # - # This is where the calendar is located. The request paths are hard-coded. - # - is_attribute "bytemark_calendar_url" - - # - # This is where the Bytemark authentication server is located. - # - is_attribute "bytemark_auth_url" - - # - # This is the level of SSL verification used when making external HTTPS connections. - # - is_attribute "remote_https_verify_mode" - - # - # This is the default timeout when making remote HTTP requests - # - is_attribute "remote_http_timeout" - - # - # This is the default sleep time after an authentication attempt has failed. - # - is_attribute "failed_login_delay" - def builder_setup @result = Mauve::Server.instance end diff --git a/lib/mauve/mauve_time.rb b/lib/mauve/mauve_time.rb index f564fdb..dfbf99b 100644 --- a/lib/mauve/mauve_time.rb +++ b/lib/mauve/mauve_time.rb @@ -98,12 +98,37 @@ class Time t end + # Returns the bank_holidays array, or an empty array if bank_holidays hasn't + # been set. + # + # + def bank_holidays + @bank_holidays ||= [] + end + + # This sets the bank holiday dates for the bank_holiday? check. + # + # @param [Array] arg An array of Date of bank holidays + # @returns [Array] + # + def bank_holidays=(arg) + raise ArgumentError unless arg.is_a?(Array) and arg.all?{|a| a.is_a?(Date)} + @bank_holidays = arg + end + + # This relies on bank_holidays being set. + # + def bank_holiday? + today = Date.new(self.year, self.month, self.day) + self.bank_holidays.any?{|bh| bh == today} + end + # Test to see if we're in working hours. The working day is from 8.30am until # 17:00 # # @return [Boolean] def working_hours? - (1..5).include?(self.wday) and ((9..16).include?(self.hour) or (self.hour == 8 && self.min >= 30)) + !bank_holiday? and (1..5).include?(self.wday) and ((9..16).include?(self.hour) or (self.hour == 8 && self.min >= 30)) end # Test to see if it is currently daytime. The daytime day is 14 hours long @@ -113,7 +138,6 @@ class Time (8..21).include?(self.hour) end - # We're always in wallclock hours # # @return [true] diff --git a/lib/mauve/notification.rb b/lib/mauve/notification.rb index d06e03a..5877e0f 100644 --- a/lib/mauve/notification.rb +++ b/lib/mauve/notification.rb @@ -163,8 +163,9 @@ module Mauve # Test to see if we're in working hours. See Time#working_hours? # # @return [Boolean] - def working_hours? + def working_hours? @test_time = @time if @test_time.nil? + @test_time.bank_holidays = Server.instance.bank_holidays @test_time.working_hours? end diff --git a/lib/mauve/notifiers/xmpp.rb b/lib/mauve/notifiers/xmpp.rb index a0ad86e..b291442 100644 --- a/lib/mauve/notifiers/xmpp.rb +++ b/lib/mauve/notifiers/xmpp.rb @@ -604,7 +604,10 @@ EOF end begin - ack_until = Time.now.in_x_hours(n_hours, type_hours) + now = Time.now + now.bank_holidays = Server.instance.bank_holidays + + ack_until = now.in_x_hours(n_hours, type_hours) rescue RangeError return "I'm sorry, you tried to acknowedge for far too long, and my buffers overflowed!" end diff --git a/lib/mauve/people_list.rb b/lib/mauve/people_list.rb index eab4ae3..0433034 100644 --- a/lib/mauve/people_list.rb +++ b/lib/mauve/people_list.rb @@ -35,6 +35,8 @@ module Mauve arr = arr.flatten when String arr = [arr] + when Proc + arr = [arr] else logger.warn "Not sure what to do with #{arr.inspect} -- converting to string, and continuing" arr = [arr.to_s] @@ -62,10 +64,12 @@ module Mauve # # @return [Array] def people - l = list.collect do |name| - Configuration.current.people.has_key?(name) ? Configuration.current.people[name] : nil - end.reject{|person| person.nil?} + name.is_a?(Proc) ? name.call : name + end.flatten.compact.uniq.collect do |name| + Configuration.current.people[name] + end.compact + # # Hmm.. no-one in the list?! # diff --git a/lib/mauve/person.rb b/lib/mauve/person.rb index 1cf4ea0..929f511 100644 --- a/lib/mauve/person.rb +++ b/lib/mauve/person.rb @@ -3,23 +3,15 @@ require 'timeout' require 'log4r' module Mauve - class Person < Struct.new(:username, :password, :urgent, :normal, :low, :email, :xmpp, :sms) + class Person + attr_reader :username, :password, :urgent, :normal, :low, :email, :xmpp, :sms attr_reader :notification_thresholds, :last_pop3_login, :suppressed, :notifications - + attr_reader :notify_when_off_sick, :notify_when_on_holiday + # Set up a new Person # - # @param [Hash] args The options for setting up the person - # @option args [String] :username The person's username - # @option args [String] :password The SHA1 sum of the person's password - # @option args [String] :holiday_url The URL that can be checked by Mauve::CalendarInterface#is_user_on_holiday? - # @option args [Proc] :urgent The block to execute when an urgent-level notification is issued - # @option args [Proc] :normal The block to execute when an normal-level notification is issued - # @option args [Proc] :low The block to execute when an low-level notification is issued - # @option args [String] :email The person's email address - # @option args [String] :sms The person's mobile number - # - def initialize(*args) + def initialize(username) @notification_thresholds = nil @suppressed = false # @@ -28,9 +20,85 @@ module Mauve @last_pop3_login = {:from => nil, :at => nil} @notifications = [] - super(*args) - end + @username = username + @password = nil + @urgent = lambda { false } + @normal = lambda { false } + @low = lambda { false } + @email = @sms = @xmpp = nil + @notify_when_on_holiday = @notify_when_off_sick = false + end + + # Determines if a user should be notified if they're ill. + # + # @return [Boolean] + # + def notify_when_off_sick! + @notify_when_off_sick = true + end + + # Determines if a user should be notified if they're on their holdiays. + # + # @return [Boolean] + # + def notify_when_on_holiday! + @notify_when_on_holiday = true + end + + # Sets the Proc to call for urgent notifications + # + def urgent=(block) + raise ArgumentError unless block.is_a?(Proc) + @urgent = block + end + + # Sets the Proc to call for normal notifications + # + def normal=(block) + raise ArgumentError unless block.is_a?(Proc) + @normal = block + end + + # Sets the Proc to call for low notifications + # + def low=(block) + raise ArgumentError unless block.is_a?(Proc) + @low = block + end + + # Sets the email parameter + # + # + def email=(arg) + raise ArgumentError unless arg.is_a?(String) + @email = arg + end + + # Sets the sms parameter + # + # + def sms=(arg) + raise ArgumentError unless arg.is_a?(String) + @sms = arg + end + + # Sets the xmpp parameter + # + # + def xmpp=(arg) + raise ArgumentError unless arg.is_a?(String) + @xmpp = arg + end + + # Sets the password parameter + # + # + def password=(arg) + raise ArgumentError unless arg.is_a?(String) + @password=arg + end + # @return Log4r::Logger def logger ; @logger ||= Log4r::Logger.new self.class.to_s ; end @@ -39,8 +107,6 @@ module Mauve # @return [Boolean] def suppressed? ; @suppressed ; end - def holiday_url ; nil ; end - # Works out if a notification should be suppressed. If no parameters are supplied, it will # # @param [Time] Theoretical time of notification @@ -155,8 +221,7 @@ module Mauve # @param [Mauve::Alert] alert Alert we're notifiying about # # @return [Boolean] if the notification was successful - def send_alert(level, alert) - now = Time.now + def send_alert(level, alert, now=Time.now) was_suppressed = @suppressed @suppressed = self.should_suppress? @@ -168,7 +233,7 @@ module Mauve # We only suppress notifications if we were suppressed before we started, # and are still suppressed. # - if @suppressed or self.is_on_holiday? + if @suppressed or self.is_on_holiday?(now) or self.is_off_sick?(now) note = "#{alert.update_type.capitalize} notification to #{self.username} suppressed" logger.info note + " about #{alert}." History.create(:alerts => [alert], :type => "notification", :event => note) @@ -217,20 +282,19 @@ module Mauve end end - # - # - # - def alert_during - - end - # Whether the person is on holiday or not. # # @return [Boolean] True if person on holiday, false otherwise. - def is_on_holiday? () - return false if holiday_url.nil? or holiday_url.empty? + def is_on_holiday?(at=Time.now) + return false if self.notify_when_on_holiday + + return CalendarInterface.is_user_on_holiday?(self.username, at) + end + + def is_off_sick?(at=Time.now) + return false if self.notify_when_off_sick - return CalendarInterface.is_user_on_holiday?(holiday_url) + return CalendarInterface.is_user_off_sick?(self.username, at) end end diff --git a/lib/mauve/processor.rb b/lib/mauve/processor.rb index 0ac7b59..acf72b3 100644 --- a/lib/mauve/processor.rb +++ b/lib/mauve/processor.rb @@ -57,14 +57,11 @@ module Mauve to_delete = [] - @transmission_id_cache.each do |tid, received_at| - to_delete << tid if (now - received_at) > @transmission_cache_expire_time + @transmission_id_cache = @transmission_id_cache.delete_if do |cache_data| + tid, received_at = cache_data + (now - received_at) > @transmission_cache_expire_time end - to_delete.each do |tid| - @transmission_id_cache.delete(tid) - end - @transmission_cache_checked_at = now end @@ -197,6 +194,11 @@ module Mauve sz.times do process_packet(*Server.packet_pop) end + + # + # Now expire the cache. This will only get processed at most once every minute. + # + expire_transmission_id_cache end def timer_should_stop? diff --git a/lib/mauve/server.rb b/lib/mauve/server.rb index 2b0e101..366191c 100644 --- a/lib/mauve/server.rb +++ b/lib/mauve/server.rb @@ -50,21 +50,10 @@ module Mauve @notification_buffer = [] # - # Set the auth/calendar URLs + # Bank Holidays -- this list is kept here, because I can't think of + # anywhere else to put it. # - @bytemark_auth_url = nil - @bytemark_calendar_url = nil - - # - # Set a couple of params for remote HTTP requests. - # - @remote_http_timeout = 5 - @remote_https_verify_mode = OpenSSL::SSL::VERIFY_PEER - - # - # Rate limit login attempts to limit the success of brute-forcing. - # - @failed_login_delay = 1 + @bank_holidays = nil # # Set up a blank config. @@ -114,83 +103,6 @@ module Mauve @notification_buffer end - # Set the calendar URL. - # - # @param [String] arg - # @return [URI] - def bytemark_calendar_url=(arg) - raise ArgumentError, "bytemark_calendar_url must be a string" unless arg.is_a?(String) - - @bytemark_calendar_url = URI.parse(arg) - - # - # Make sure we get an HTTP URL. - # - raise ArgumentError, "bytemark_calendar_url must be an HTTP(S) URL." unless %w(http https).include?(@bytemark_calendar_url.scheme) - - # - # Set a default request path, if none was given - # - @bytemark_calendar_url.path="/" if @bytemark_calendar_url.path.empty? - - @bytemark_calendar_url - end - - # Set the Bytemark Authentication URL - # - # @param [String] arg - # @return [URI] - def bytemark_auth_url=(arg) - raise ArgumentError, "bytemark_auth_url must be a string" unless arg.is_a?(String) - - @bytemark_auth_url = URI.parse(arg) - # - # Make sure we get an HTTP URL. - # - raise ArgumentError, "bytemark_auth_url must be an HTTP(S) URL." unless %w(http https).include?(@bytemark_auth_url.scheme) - - # - # Set a default request path, if none was given - # - @bytemark_auth_url.path="/" if @bytemark_auth_url.path.empty? - - @bytemark_auth_url - end - - # Sets the timeout when making remote HTTP requests - # - # @param [Integer] arg - # @return [Integer] - def remote_http_timeout=(arg) - raise ArgumentError, "initial_sleep must be an integer" unless s.is_a?(Integer) - @remote_http_timeout = arg - end - - # Sets the SSL verification mode when makeing remote HTTPS requests - # - # @param [String] arg must be one of "none" or "peer" - # @return [Constant] - def remote_https_verify_mode=(arg) - @remote_https_verify_mode = case arg - when "peer" - OpenSSL::SSL::VERIFY_PEER - when "none" - OpenSSL::SSL::VERIFY_NONE - else - raise ArgumentError, "remote_https_verify_mode must be either 'peer' or 'none'" - end - end - - # Set the delay added following a failed login attempt. - # - # @param [Numeric] arg Number of seconds to delay following a failed login attempt - # @return [Numeric] - # - def failed_login_delay=(arg) - raise ArgumentError, "initial_sleep must be numeric" unless arg.is_a?(Numeric) - @failed_login_delay = arg - end - # Set the sleep period during which notifications about old alerts are # suppressed. # @@ -207,6 +119,24 @@ module Mauve Time.now < self.started_at + self.initial_sleep end + # Check with the calendar for the list of bank holidays + # + # + def bank_holidays + # + # Update the bank holidays list hourly. + # + if @bank_holidays.nil? or + @bank_holidays_last_checked_at.nil? or + @bank_holidays_last_checked_at < (Time.now - 1.hour) + + @bank_holidays = CalendarInterface.get_bank_holiday_list(Time.now) + @bank_holidays_last_checked_at = Time.now + end + + @bank_holidays + end + # return [Log4r::Logger] def logger @logger ||= Log4r::Logger.new(self.class.to_s) diff --git a/lib/mauve/web_interface.rb b/lib/mauve/web_interface.rb index 16e7da2..a8e1ece 100644 --- a/lib/mauve/web_interface.rb +++ b/lib/mauve/web_interface.rb @@ -218,9 +218,13 @@ EOF note = params[:note] || nil n_hours = (n_hours.to_f > 188 ? 188 : n_hours.to_f) + type_hours = "daytime" unless %w(daytime working wallclock).include?(type_hours) if ack_until.to_s.empty? - ack_until = Time.now.in_x_hours(n_hours, type_hours.to_s) + now = Time.now + now.bank_holidays = Server.instance.bank_holidays + + ack_until = now.in_x_hours(n_hours, type_hours.to_s) else ack_until = Time.at(ack_until.to_i) end @@ -275,12 +279,14 @@ EOF # n_hours = ( n_hours > 300 ? 300 : n_hours ) type_hours = "daytime" unless %w(daytime working wallclock).include?(type_hours) - ack_until = Time.now.in_x_hours(n_hours, type_hours) + now = Time.now + now.bank_holidays = Server.instance.bank_holidays + ack_until = now.in_x_hours(n_hours, type_hours) # # Make sure we can't ack longer than a week. # - max_ack = (Time.now + 86400*8) + max_ack = (Time.now + Configuration.current.max_acknowledgement_time) ack_until = max_ack if ack_until > max_ack # @@ -359,8 +365,13 @@ EOF type_hours = params[:type_hours].to_s note = params[:note] || nil + type_hours = "daytime" unless %w(daytime working wallclock).include?(type_hours) + if ack_until == 0 - ack_until = Time.now.in_x_hours(n_hours, type_hours) + now = Time.now + now.bank_holidays = Server.instance.bank_holidays + + ack_until = now.in_x_hours(n_hours, type_hours) else ack_until = Time.at(ack_until) end diff --git a/lib/object_builder.rb b/lib/object_builder.rb index ebd655b..ccb2c63 100644 --- a/lib/object_builder.rb +++ b/lib/object_builder.rb @@ -181,6 +181,20 @@ class ObjectBuilder end end + # This catches all methods available for a provider, as needed. + # + # Missing methods / bad arguments etc. are caught in the + # ObjectBuilder#parse method, via NoMethodError. + # + def method_missing(name, value=nil) + if value + result.send("#{name}=".to_sym, value) + else + result.send(name.to_sym) + end + end + + class << self # Defines a new builder diff --git a/test/tc_mauve_alert.rb b/test/tc_mauve_alert.rb index 2b8af6f..3af9075 100644 --- a/test/tc_mauve_alert.rb +++ b/test/tc_mauve_alert.rb @@ -95,8 +95,7 @@ EOF end def test_acknowledge! - person = Mauve::Person.new - person.username = "test-user" + person = Mauve::Person.new("test-user") Server.instance.setup diff --git a/test/tc_mauve_authentication.rb b/test/tc_mauve_authentication.rb index d0f2d4f..c364aca 100644 --- a/test/tc_mauve_authentication.rb +++ b/test/tc_mauve_authentication.rb @@ -26,9 +26,7 @@ class TcMauveAuthentication < Mauve::UnitTest def test_default_auth_always_fails config=<<EOF -server { - failed_login_delay 0 -} +failed_login_delay 0 EOF Configuration.current = ConfigurationBuilder.parse(config) @@ -43,9 +41,7 @@ EOF def test_local_auth config=<<EOF -server { - failed_login_delay 0 -} +failed_login_delay 0 person ("test") { password "#{Digest::SHA1.new.hexdigest("password")}" @@ -70,9 +66,7 @@ EOF def test_local_auth config=<<EOF -server { - failed_login_delay 0 -} +failed_login_delay 0 person ("nopass") { } @@ -97,10 +91,8 @@ EOF # test2: POKvBqLT7 # config=<<EOF -server { - failed_login_delay 0 - bytemark_auth_url "https://auth.bytemark.co.uk/" -} +failed_login_delay 0 +bytemark_auth_url "https://auth.bytemark.co.uk/" person ("test1") { } diff --git a/test/tc_mauve_calendar_interface.rb b/test/tc_mauve_calendar_interface.rb new file mode 100644 index 0000000..ddf4039 --- /dev/null +++ b/test/tc_mauve_calendar_interface.rb @@ -0,0 +1,155 @@ +$:.unshift "../lib" + +require 'th_mauve' +require 'mauve/calendar_interface' +require 'mauve/configuration_builder' +require 'mauve/configuration' +require 'webmock' +# +# Ugh webmock is annoying. +WebMock.allow_net_connect! + +class TcMauveCalendarInterface < Mauve::UnitTest + + include WebMock::API + include Mauve + + def setup + WebMock.disable_net_connect! + super + end + + def teardown + WebMock.reset! + WebMock.allow_net_connect! + super + end + + def test_get_attendees + attendees = %w(test1 test2) + stub_request(:get, "http://localhost/calendar/api/attendees/support_shift/2011-08-01T00:00:00"). + to_return(:status => 200, :body => YAML.dump(attendees)) + + config =<<EOF +bytemark_calendar_url "http://localhost/calendar" +EOF + + Configuration.current = ConfigurationBuilder.parse(config) + + assert_equal(attendees, CalendarInterface.get_attendees("support_shift")) + end + + def test_is_user_on_holiday? + attendees = %w(test1 test2) + stub_request(:get, "http://localhost/calendar/api/attendees/staff_holiday/2011-08-01T00:00:00"). + to_return(:status => 200, :body => YAML.dump(attendees)) + + + config =<<EOF +bytemark_calendar_url "http://localhost/calendar" +EOF + + Configuration.current = ConfigurationBuilder.parse(config) + + assert(CalendarInterface.is_user_on_holiday?("test1")) + assert(!CalendarInterface.is_user_on_holiday?("test3")) + end + + def test_is_user_off_sick? + attendees = %w(test1 test2) + stub_request(:get, "http://localhost/calendar/api/attendees/sick_period/2011-08-01T00:00:00"). + to_return(:status => 200, :body => YAML.dump(attendees)) + + config =<<EOF +bytemark_calendar_url "http://localhost/calendar" +EOF + + Configuration.current = ConfigurationBuilder.parse(config) + + assert(CalendarInterface.is_user_off_sick?("test1")) + assert(!CalendarInterface.is_user_off_sick?("test3")) + end + + def test_do_get + url = "http://localhost/" + + # + # This sets up two redirects, followed by the answer (below) + # + 2.times do |x| + next_url = url + "#{x}/" + stub_request(:get, url). + to_return(:status => 301, :body => nil, :headers => {:location => next_url}) + url = next_url + end + + # + # And finally the answer. + # + stub_request(:get, url). + to_return(:status => 200, :body => "OK!", :headers => {}) + + # + # Now do_get should return "OK!" when the maximum number of redirects is set to two. + # + result = nil + assert_nothing_raised{ result = CalendarInterface.__send__(:do_get, "http://localhost/", 2) } + assert_equal("OK!",result) + + # + # do_get should return nil when the maximum number of redirects is set to two. + # + assert_nothing_raised{ result = CalendarInterface.__send__(:do_get, "http://localhost/", 1) } + assert_nil(result) + + # + # Pop the warning about the redirect off the end of the log. + # + logger_pop + end + + def test_do_get_with_cache + url = "http://localhost/" + + # + # This stubs the request to give out the time + # + stub_request(:get, url). + to_return( lambda{ {:status => 200, :body => YAML.dump(Time.now), :headers => {}} } ) + + # + # This reponse should not be cached, the cache-until paramter is "now" + # + assert_equal(Time.now, CalendarInterface.__send__(:do_get_with_cache, url, Time.now)) + + # + # Since the last request wasn't cached, the next one should give back + # "now", and should be cached for the next 10 seconds. + # + Timecop.freeze(Time.now + 5) + assert_equal(Time.now, CalendarInterface.__send__(:do_get_with_cache, url, Time.now + 10)) + + # + # This should have been cached from the last query. + # + Timecop.freeze(Time.now + 5) + assert_equal(Time.now - 5, CalendarInterface.__send__(:do_get_with_cache, url, Time.now + 10)) + + # + # Finally, this should now have expired from the cache. + # + Timecop.freeze(Time.now + 5) + assert_equal(Time.now, CalendarInterface.__send__(:do_get_with_cache, url, Time.now + 10)) + + Timecop.freeze(Time.now + 50) + cache = CalendarInterface.__send__(:clean_cache) + assert(cache.empty?) + end + + +end + + + + + diff --git a/test/tc_mauve_notification.rb b/test/tc_mauve_notification.rb index a447207..d0c2bab 100644 --- a/test/tc_mauve_notification.rb +++ b/test/tc_mauve_notification.rb @@ -442,9 +442,15 @@ people_list("testers", %w(test1 test2)) { alert_group("test") { level URGENT + notify("test1") notify("test2") notify("testers") + + notify("testers") { + every 60 + during { hours_in_day (3) } + } } EOF diff --git a/test/tc_mauve_people_list.rb b/test/tc_mauve_people_list.rb index 2d5da6d..fd8bda9 100644 --- a/test/tc_mauve_people_list.rb +++ b/test/tc_mauve_people_list.rb @@ -117,4 +117,29 @@ EOF end end + + def test_dynamic_people_list + # + # Allows us to pick up notifications sent. + # + $sent_notifications = [] + + config =<<EOF + +person "test1" + +person "test2" + +# +# This should oscillate between test1 and test2. +# +people_list "testers", lambda { $ans = ($ans == "test1" ? "test2" : "test1") } + +EOF + Configuration.current = ConfigurationBuilder.parse(config) + people_list = Configuration.current.people_lists["testers"] + assert_equal([Configuration.current.people["test1"]], people_list.people) + assert_equal([Configuration.current.people["test2"]], people_list.people) + end + end diff --git a/test/tc_mauve_time.rb b/test/tc_mauve_time.rb index 7a8fefa..6e5989b 100644 --- a/test/tc_mauve_time.rb +++ b/test/tc_mauve_time.rb @@ -35,8 +35,15 @@ class TestMauveTime < Mauve::UnitTest assert_equal(hour_1, t.in_x_hours(1,"working")) assert_equal(hour_0, t.in_x_hours(0,"working")) + end + + def test_bank_holiday? + x = Time.now + assert(!x.bank_holiday?) + x.bank_holidays << Date.new(x.year, x.month, x.day) + assert(x.bank_holiday?) end diff --git a/test/th_mauve.rb b/test/th_mauve.rb index ce29e11..99eaaed 100644 --- a/test/th_mauve.rb +++ b/test/th_mauve.rb @@ -55,6 +55,7 @@ module Mauve def setup reset_all_singletons + reset_mauve_configuration setup_logger setup_time end @@ -108,6 +109,10 @@ module Mauve Timecop.return end + def reset_mauve_configuration + Mauve::Configuration.current = Mauve::Configuration.new + end + def reset_all_singletons Mauve.constants.collect{|const| Mauve.const_get(const)}.each do |klass| next unless klass.respond_to?(:instance) |