developer.intra2net.com Git - pingcheck/blob - src/host/hoststatus.cpp

   1 /*
   2 The software in this package is distributed under the GNU General
   3 Public License version 2 (with a special exception described below).
   4
   5 A copy of GNU General Public License (GPL) is included in this distribution,
   6 in the file COPYING.GPL.
   7
   8 As a special exception, if other files instantiate templates or use macros
   9 or inline functions from this file, or you compile this file and link it
  10 with other works to produce a work based on this file, this file
  11 does not by itself cause the resulting work to be covered
  12 by the GNU General Public License.
  13
  14 However the source code for this file must still be made available
  15 in accordance with section (3) of the GNU General Public License.
  16
  17 This exception does not invalidate any other reasons why a work based
  18 on this file might be covered by the GNU General Public License.
  19 */
  20 #include "host/hoststatus.h"
  21
  22 #include <iostream>
  23 #include <logfunc.hpp>
  24
  25 #include "boost_assert_handler.h"
  26
  27 using namespace std;
  28 using I2n::Logger::GlobalLogger;
  29
  30 //-----------------------------------------------------------------------------
  31 // HostStatus
  32 //-----------------------------------------------------------------------------
  33
  34 /**
  35  * @param host_address The address of the host it has to analyze.
  36  * @param ping_fail_percentage_limit The percentage threshold of pings that can
  37  * fail.
  38  * @param link_analyzer The object used to notify the status of the host.
  39  */
  40 HostStatus::HostStatus(
  41         const string &host_address,
  42         const int ping_fail_limit_percentage,
  43         const LinkStatusItem link_analyzer
  44 ) :
  45     HostAddress( host_address ),
  46     LinkAnalyzer( link_analyzer ),
  47     PingFailLimitPercentage( ping_fail_limit_percentage ),
  48     ResolvedIpCount( 0 ),
  49     PingsPerformedCount( 0 ),
  50     PingsFailedCount( 0 ),
  51     ExceededPingFailedLimit( false )
  52 {
  53     BOOST_ASSERT( !HostAddress.empty() );
  54     BOOST_ASSERT( ( 0 <= PingFailLimitPercentage ) && ( PingFailLimitPercentage <= 100 ) );
  55 }
  56
  57 HostStatus::~HostStatus()
  58 {
  59 }
  60
  61 /**
  62  * @param resolved_ip_count The number of IPs resolved for the host.
  63  */
  64 void HostStatus::set_resolved_ip_count( const int resolved_ip_count )
  65 {
  66     BOOST_ASSERT( 1 <= resolved_ip_count );
  67
  68     ResolvedIpCount = resolved_ip_count;
  69
  70     GlobalLogger.notice() << "Stat(" << HostAddress << "): "
  71         << PingsFailedCount << " fail/" << PingsPerformedCount << " pings/"
  72         << ResolvedIpCount << " IPs: #IPs set";
  73 }
  74
  75 /**
  76  * @return true if the amount of failed pings given to the host exceeded the
  77  * limit.
  78  */
  79 bool HostStatus::exceeded_ping_failed_limit() const
  80 {
  81     return ExceededPingFailedLimit;
  82 }
  83
  84 /**
  85  * Adds a ping status (success or failure).
  86  * @param ping_success
  87  */
  88 void HostStatus::update_ping_statistics( bool ping_success )
  89 {
  90     GlobalLogger.notice() << "Stat(" << HostAddress << "): "
  91         << PingsFailedCount << " fail/" << PingsPerformedCount << " pings/"
  92         << ResolvedIpCount << " IPs: add ping with success=" << ping_success;
  93
  94     BOOST_ASSERT( 1 <= ResolvedIpCount );
  95     BOOST_ASSERT( 0 <= PingsPerformedCount );
  96     BOOST_ASSERT( PingsFailedCount <= PingsPerformedCount );
  97
  98     increase_ping_performed_count();
  99
 100     if ( !ping_success )
 101     {
 102         increase_ping_failed_count();
 103     }
 104
 105     analyze_ping_failed_count();
 106
 107     // after we tried all IPs resolved for this host, we can analyze how many
 108     // failed
 109     if ( tried_all_resolved_ip() )
 110     {
 111         analyze_ping_statistics();
 112
 113         reset_ping_counters();
 114     }
 115
 116     BOOST_ASSERT( PingsFailedCount <= PingsPerformedCount );
 117 }
 118
 119
 120 bool HostStatus::tried_all_resolved_ip() const
 121 {
 122     BOOST_ASSERT( ( 0 < PingsPerformedCount ) && ( PingsPerformedCount <= ResolvedIpCount ) );
 123
 124     return ( PingsPerformedCount == ResolvedIpCount );
 125 }
 126
 127 void HostStatus::analyze_ping_statistics()
 128 {
 129     BOOST_ASSERT( !HostAddress.empty() );
 130     BOOST_ASSERT( PingsPerformedCount == ResolvedIpCount );
 131
 132     // notify if the amount of pings that failed exceed the limit
 133     if ( exceeded_ping_failed_limit() )
 134     {
 135         GlobalLogger.notice() << "Stat(" << HostAddress << "): "
 136             << PingsFailedCount << " fail/" << PingsPerformedCount << " pings/"
 137             << ResolvedIpCount << " IPs: notify down";
 138         LinkAnalyzer->notify_host_down( HostAddress );
 139     }
 140     else
 141     {
 142         GlobalLogger.notice() << "Stat(" << HostAddress << "): "
 143             << PingsFailedCount << " fail/" << PingsPerformedCount << " pings/"
 144             << ResolvedIpCount << " IPs: notify up";
 145         LinkAnalyzer->notify_host_up( HostAddress );
 146     }
 147 } //lint !e1762
 148
 149 void HostStatus::reset_ping_counters()
 150 {
 151     PingsPerformedCount = 0;
 152     PingsFailedCount = 0;
 153 }
 154
 155 void HostStatus::increase_ping_performed_count()
 156 {
 157     ++PingsPerformedCount;
 158
 159     BOOST_ASSERT( ( 0 < PingsPerformedCount ) && ( PingsPerformedCount <= ResolvedIpCount ) );
 160 }
 161
 162 void HostStatus::increase_ping_failed_count()
 163 {
 164     ++PingsFailedCount;
 165
 166     BOOST_ASSERT( ( 0 <= PingsFailedCount ) && ( PingsFailedCount <= PingsPerformedCount ) );
 167 }
 168
 169 void HostStatus::analyze_ping_failed_count()
 170 {
 171     BOOST_ASSERT( ( 0 <= PingFailLimitPercentage ) && ( PingFailLimitPercentage <= 100 ) );
 172     BOOST_ASSERT( ( 0 <= PingsFailedCount ) && ( PingsFailedCount <= PingsPerformedCount ) );
 173
 174     int ping_fail_limit_count = ( ResolvedIpCount * PingFailLimitPercentage ) / 100;
 175
 176     // keep a boolean variable because the PingsFailedCount can be reseted
 177     if ( PingsFailedCount > ping_fail_limit_count )
 178     {
 179         ExceededPingFailedLimit = true;
 180
 181         GlobalLogger.notice() << "Stat(" << HostAddress << "): "
 182             << PingsFailedCount << " fail/" << PingsPerformedCount << " pings/"
 183             << ResolvedIpCount << " IPs: exceed limit=" << ping_fail_limit_count;
 184     }
 185     else
 186     {
 187         ExceededPingFailedLimit = false;
 188
 189         GlobalLogger.notice() << "Stat(" << HostAddress << "): "
 190             << PingsFailedCount << " fail/" << PingsPerformedCount << " pings/"
 191             << ResolvedIpCount << " IPs: below limit=" << ping_fail_limit_count;
 192     }
 193 }