developer.intra2net.com Git - pingcheck/blob - src/host/pingscheduler.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/pingscheduler.h"
  21
  22 #include <iostream>
  23 #include <limits>
  24
  25 #include <boost/bind.hpp>
  26 #include <boost/foreach.hpp>
  27
  28 #include <logfunc.hpp>
  29
  30 #include "boost_assert_handler.h"
  31 #include "host/pingerfactory.h"
  32 #include "dns/dnsmaster.h"
  33 #include "icmp/icmppinger.h"
  34 #include "link/linkstatus.h"
  35
  36 using namespace std;
  37 using boost::asio::io_service;
  38 using boost::bind;
  39 using boost::date_time::time_resolution_traits_adapted64_impl;
  40 using boost::posix_time::microsec_clock;
  41 using boost::posix_time::ptime;
  42 using boost::posix_time::seconds;
  43 using boost::shared_ptr;
  44 using I2n::Logger::GlobalLogger;
  45
  46 //-----------------------------------------------------------------------------
  47 // PingScheduler
  48 //-----------------------------------------------------------------------------
  49
  50 /**
  51  * @brief Parameterized constructor.
  52  *
  53  * @param io_serv The one @c io_serv object that controls async processing
  54  * @param network_interface The name of the network interface originating the pings.
  55  * @param destination_address The remote address to ping.
  56  * @param destination_port The remote port to ping.
  57  * @param ping_protocol_list A list of protocols to use.
  58  * @param ping_interval_in_sec Amount of time between each ping.
  59  * @param ping_fail_percentage_limit Maximum amount of pings that can fail.
  60  * @param link_analyzer The object to monitor the link status.
  61  * @param first_delay Delay in seconds from start_pinging to first ping attempt
  62  */
  63 PingScheduler::PingScheduler(
  64         const IoServiceItem io_serv,
  65         const string &network_interface,
  66         const string &destination_address,
  67         const uint16_t destination_port,
  68         const PingProtocolList &ping_protocol_list,
  69         const long ping_interval_in_sec,
  70         const int ping_fail_percentage_limit,
  71         const int ping_reply_timeout,
  72         LinkStatusItem link_analyzer,
  73         const int first_delay
  74
  75 ) :
  76     IoService( io_serv ),
  77     NetworkInterfaceName( network_interface ),
  78     DestinationAddress( destination_address ),
  79     DestinationPort( destination_port ),
  80     Protocols( ping_protocol_list ),
  81     ProtocolIter(),
  82     PingIntervalInSec( ping_interval_in_sec ),
  83     FirstDelay( first_delay ),
  84     NextPingTimer( *io_serv ),
  85     TimeSentLastPing( microsec_clock::universal_time() ),
  86     PingReplyTimeout( ping_reply_timeout ),
  87     HostAnalyzer( destination_address, ping_fail_percentage_limit, link_analyzer ),
  88     Resolver(),
  89     Ping(),
  90     WantToPing( false ),
  91     LogPrefix(),
  92     ContinueOnOutdatedIps( false );
  93 {
  94     BOOST_ASSERT( !network_interface.empty() );
  95     BOOST_ASSERT( !destination_address.empty() );
  96     BOOST_ASSERT( ( 0 < destination_port ) &&
  97                   ( destination_port < numeric_limits<uint16_t>::max() ) );
  98     BOOST_ASSERT( 0 < ping_interval_in_sec );
  99     BOOST_ASSERT( (0 <= ping_fail_percentage_limit) &&
 100                   ( ping_fail_percentage_limit <= 100) );
 101
 102     update_log_prefix();
 103
 104     init_ping_protocol();
 105 }
 106
 107 /**
 108  * @brief Destructor.
 109  */
 110 PingScheduler::~PingScheduler()
 111 {
 112 }
 113
 114 void PingScheduler::stop_pinging()
 115 {
 116     // stop pinger, which will probably call ping_done_handler --> re-new NextPingTimer
 117     GlobalLogger.debug() << "scheduler: stop pinging" << endl;
 118     Ping->stop_pinging();
 119     Resolver->cancel_resolve();
 120
 121     // now cancel the own timer
 122     GlobalLogger.debug() << "scheduler: cancel timer" << endl;
 123     NextPingTimer.cancel();
 124 }
 125
 126 /**
 127  * @brief Start into infinite loop of calls to ping
 128  *
 129  * Does not start yet but set NextPingTimer (possibly to 0), so action starts
 130  *   when io_service is started
 131  */
 132 void PingScheduler::start_pinging()
 133 {
 134     if ( FirstDelay > 0 )
 135         GlobalLogger.info() << "Delaying first ping by " << FirstDelay << "s";
 136     else
 137         GlobalLogger.info() << "Schedule ping as soon as possible";
 138
 139     (void) NextPingTimer.expires_from_now( seconds( FirstDelay ) );
 140     NextPingTimer.async_wait( bind( &PingScheduler::ping, this,
 141                                           boost::asio::placeholders::error ) );
 142 }
 143
 144
 145 /**
 146  * @brief call Ping::ping and schedule a call to ping_done_handler when finished
 147  */
 148 void PingScheduler::ping(const boost::system::error_code &error)
 149 {
 150     if ( error )
 151     {   // get here, e.g. by NextPingTimer.cancel in stop_pinging
 152         if ( error ==  boost::asio::error::operation_aborted )
 153             GlobalLogger.error() << "Timer for ping was cancelled! "
 154                                  << "Stopping" << endl;
 155         else
 156             GlobalLogger.error() << "Received error " << error
 157                                  << " waiting for ping! Stopping"
 158                                  << endl;
 159         return;
 160     }
 161
 162     // ping as soon as dns is ready
 163     WantToPing = true;
 164     try_to_ping();
 165 }
 166
 167
 168 void PingScheduler::try_to_ping()
 169 {
 170     if ( !WantToPing )
 171     {
 172         GlobalLogger.info() << "PingScheduler: not pinging (not requested to)";
 173         return;
 174     }
 175     else if ( Resolver && Resolver->is_resolving() )
 176     {
 177         GlobalLogger.info() << "PingScheduler: not pinging (DNS not finished)";
 178         return;
 179     }
 180     else if ( !Resolver )
 181         // should not happen, but check anyway
 182         GlobalLogger.warning() << LogPrefix << "Have no resolver!";
 183
 184     GlobalLogger.info() << "PingScheduler: start ping";
 185     WantToPing = false;
 186
 187     HostAddress ip = Resolver->get_next_ip();
 188     if ( !ip.is_valid() && ContinueOnOutdatedIps)
 189     {
 190         GlobalLogger.info() << LogPrefix << "Checking for outdated IPs";
 191         bool check_up_to_date = false;
 192         ip = Resolver->get_next_ip(check_up_to_date);
 193     }
 194     if ( ip.is_valid() )
 195         Ping->ping(
 196                 Resolver->get_next_ip().get_ip(),
 197                 DestinationPort,
 198                 boost::bind(&PingScheduler::ping_done_handler, this, _1)
 199         );
 200     else
 201     {   // should not happen
 202         GlobalLogger.error() << LogPrefix << "No IP to ping "
 203                              << "-- this should not have happened!!";
 204         WantToPing = true;
 205         if ( !Resolver.is_resolving() )
 206             start_resolving_ping_address();
 207     }
 208 }
 209
 210
 211 //------------------------------------------------------------------------------
 212 // Post Processing of Ping result
 213 //------------------------------------------------------------------------------
 214
 215 /**
 216  * @brief called when Ping::ping is done; calls functions to update
 217  *   statistics, ping interval and elapsed time;
 218  *   schedules a call to ping, thereby closing the loop
 219  */
 220 void PingScheduler::ping_done_handler( const bool ping_success )
 221 {
 222     // post-processing
 223     // You must call these 3 methods exactly in this order
 224     // TODO Fix this method, once it has a semantic dependency with the
 225     // update_ping_statistics method, because it depends on the PingAnalyzer
 226     // statistics to update the exceeded_ping_failed_limit
 227     HostAnalyzer.update_ping_statistics( ping_success );
 228     update_ping_interval();
 229     update_ping_elapsed_time();
 230
 231     // get next protocol, possibly start resolving IPs
 232     update_ping_protocol();
 233
 234     // schedule next ping
 235     (void) NextPingTimer.expires_from_now( seconds( PingIntervalInSec ) );
 236     NextPingTimer.async_wait( bind( &PingScheduler::ping, this,
 237                                          boost::asio::placeholders::error ) );
 238 }
 239
 240 void PingScheduler::update_ping_interval()
 241 {
 242     // have to ping more often?
 243     if ( HostAnalyzer.exceeded_ping_failed_limit() )
 244     {
 245         PingIntervalInSec.speed_up();
 246
 247         GlobalLogger.debug() << "- Speeding up ping interval to: " << PingIntervalInSec << "s"
 248                 << endl;
 249     }
 250     else
 251     {
 252         PingIntervalInSec.back_to_original();
 253
 254         GlobalLogger.debug() << "- Stick to the original ping interval: " << PingIntervalInSec << "s"
 255                 << endl;
 256     }
 257 }
 258
 259 void PingScheduler::update_ping_elapsed_time()
 260 {
 261     ptime now = microsec_clock::universal_time();
 262     time_resolution_traits_adapted64_impl::int_type elapsed_time_in_sec =
 263             (now - TimeSentLastPing).total_seconds();
 264     GlobalLogger.debug() << "- Time elapsed since last ping: " << elapsed_time_in_sec << "s" << endl;
 265
 266     TimeSentLastPing = microsec_clock::universal_time();
 267 }
 268
 269
 270 //------------------------------------------------------------------------------
 271 // Ping Protocol Rotation
 272 //------------------------------------------------------------------------------
 273
 274 void PingScheduler::init_ping_protocol()
 275 {
 276     ProtocolIter = Protocols.end();
 277     get_next_ping_protocol();
 278 }
 279
 280 void PingScheduler::update_ping_protocol()
 281 {
 282     if ( can_change_ping_protocol() )
 283     {
 284         get_next_ping_protocol();
 285     }
 286 }
 287
 288 void PingScheduler::get_next_ping_protocol()
 289 {
 290     ++ProtocolIter;
 291     if (ProtocolIter == Protocols.end())
 292         ProtocolIter = Protocols.begin();
 293     PingProtocol ping_protocol = *ProtocolIter;
 294     // --> ProtocolIter still points to currently used protocol which is
 295     //     required in dns_resolve_callback
 296
 297     if (Ping)
 298         Ping->stop_pinging();
 299
 300     Ping = PingerFactory::createPinger(ping_protocol, IoService,
 301                                        NetworkInterfaceName, PingReplyTimeout);
 302
 303     update_dns_resolver( ping_protocol );
 304 }
 305
 306 bool PingScheduler::can_change_ping_protocol() const
 307 {
 308     // TODO can_change_ping_protocol() and get_next_ping_protocol() may be implemented in a Algorithm
 309     // class that can be exchanged in this class to provide an algorithm neutral class
 310     return true;
 311 }
 312
 313 //------------------------------------------------------------------------------
 314 // DNS host name resolution
 315 //------------------------------------------------------------------------------
 316
 317 // show "!" after host name if running on outdated IPs
 318 void update_log_prefix()
 319 {
 320     std::stringstream temp;
 321     temp << "PS(" << DestinationAddress;
 322     if (ContinueOnOutdatedIps)
 323         temp << "!";
 324     temp << "): ";
 325     LogPrefix = temp.str();
 326 }
 327
 328 void PingScheduler::update_dns_resolver( PingProtocol current_protocol )
 329 {
 330     if (Resolver && Resolver->is_resolving())
 331     {
 332         GlobalLogger.warning() << "Resolver still seems to be resolving "
 333                                << "--> cancel!";
 334         Resolver->cancel_resolve();
 335     }
 336
 337     // DNS master caches created resolvers and resolved IPs, so this will
 338     // probably just return an existing resolver with already resolved IPs for
 339     // requested protocol ( ICMP/TCP is ignored, only IPv4/v6 is important)
 340     Resolver = DnsMaster::get_instance()->get_resolver_for(DestinationAddress,
 341                                                            current_protocol);
 342     // start resolving if no ips available
 343     if ( Resolver->have_up_to_date_ip() )
 344     {
 345         if (!Resolver->is_resolving())
 346             GlobalLogger.warning() << "PingScheduler: have up to date IPs but "
 347                 << "resolver seems to be resolving all the same... "
 348                 << "Start pinging anyway!";
 349         try_to_ping();
 350     }
 351     else
 352         start_resolving_ping_address();
 353 }
 354
 355 void PingScheduler::start_resolving_ping_address()
 356 {
 357     Resolver->async_resolve( boost::bind(&PingScheduler::dns_resolve_callback,
 358                                           this, _1, _2) );
 359 }
 360
 361 void PingScheduler::dns_resolve_callback(const bool was_success,
 362                                          const int cname_count)
 363 {
 364     GlobalLogger.info() << "PingScheduler: dns resolution finished "
 365                         << "with success = " << was_success << " "
 366                         << "and cname_count = " << cname_count;
 367
 368     // TODO this is too simple, but need to think more about how to update here!
 369     // (may have to switch back some time to resolver for original host or so
 370     ContinueOnOutdatedIps = true;
 371     update_log_prefix();
 372
 373     if ( was_success )
 374     {
 375         HostAnalyzer.set_resolved_ip_count( Resolver->get_resolved_ip_count());
 376         try_to_ping();
 377     }
 378     else
 379     {   // host name resolution failed; try again bypassing first outdated CNAME
 380
 381         std::string skip_host = Resolver->get_skip_cname();
 382
 383         if (skip_host.empty())
 384         {
 385             GlobalLogger.notice() << LogPrefix << "DNS failed, "
 386                 << "try anyway with cached data";
 387             HostAnalyzer.set_resolved_ip_count(0);
 388             try_to_ping();
 389         }
 390         else
 391         {
 392             GlobalLogger.notice() << LogPrefix << "DNS failed, "
 393                 << "try again skipping a CNAME and resolving "
 394                 << skip_host << " directly";
 395             Resolver = DnsMaster::get_instance()
 396                                    ->get_resolver_for(skip_host, *ProtocolIter);
 397             // the original resolver is still alive and cached by DnsMaster
 398             //   and counting down the time to re-try on its own
 399             start_resolving_ping_address();
 400         }
 401     }
 402 }