created and passed first unit tests for DNS; finished recovery from PingScheduler...

[pingcheck] / src / host / pingscheduler.cpp

/*
The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).

A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.

As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.

However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.

This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/
#include "host/pingscheduler.h"

#include <iostream>
#include <limits>

#include <boost/bind.hpp>
#include <boost/foreach.hpp>

#include <logfunc.hpp>

#include "boost_assert_handler.h"
#include "host/pingerfactory.h"
#include "dns/dnsmaster.h"
#include "icmp/icmppinger.h"
#include "link/linkstatus.h"

using namespace std;
using boost::asio::io_service;
using boost::bind;
using boost::date_time::time_resolution_traits_adapted64_impl;
using boost::posix_time::microsec_clock;
using boost::posix_time::ptime;
using boost::posix_time::seconds;
using boost::shared_ptr;
using I2n::Logger::GlobalLogger;

//-----------------------------------------------------------------------------
// PingScheduler
//-----------------------------------------------------------------------------

/**
 * @brief Parameterized constructor.
 *
 * @param io_serv The one @c io_serv object that controls async processing
 * @param network_interface The name of the network interface originating the pings.
 * @param destination_address The remote address to ping.
 * @param destination_port The remote port to ping.
 * @param ping_protocol_list A list of protocols to use.
 * @param ping_interval_in_sec Amount of time between each ping.
 * @param ping_fail_percentage_limit Maximum amount of pings that can fail.
 * @param link_analyzer The object to monitor the link status.
 * @param first_delay Delay in seconds from start_pinging to first ping attempt
 */
PingScheduler::PingScheduler(
        const IoServiceItem io_serv,
        const string &network_interface,
        const string &destination_address,
        const uint16_t destination_port,
        const PingProtocolList &ping_protocol_list,
        const long ping_interval_in_sec,
        const int ping_fail_percentage_limit,
        const int ping_reply_timeout,
        LinkStatusItem link_analyzer,
        const int first_delay

) :
    IoService( io_serv ),
    NetworkInterfaceName( network_interface ),
    DestinationAddress( destination_address ),
    DestinationPort( destination_port ),
    Protocols( ping_protocol_list ),
    ProtocolIter(),
    PingIntervalInSec( ping_interval_in_sec ),
    FirstDelay( first_delay ),
    NextPingTimer( *io_serv ),
    TimeSentLastPing( microsec_clock::universal_time() ),
    PingReplyTimeout( ping_reply_timeout ),
    HostAnalyzer( destination_address, ping_fail_percentage_limit, link_analyzer ),
    Resolver(),
    Ping(),
    WantToPing( false ),
    LogPrefix(),
    ContinueOnOutdatedIps( false )
{
    BOOST_ASSERT( !network_interface.empty() );
    BOOST_ASSERT( !destination_address.empty() );
    BOOST_ASSERT( ( 0 < destination_port ) &&
                  ( destination_port < numeric_limits<uint16_t>::max() ) );
    BOOST_ASSERT( 0 < ping_interval_in_sec );
    BOOST_ASSERT( (0 <= ping_fail_percentage_limit) &&
                  ( ping_fail_percentage_limit <= 100) );

    update_log_prefix();

    init_ping_protocol();
}

/**
 * @brief Destructor.
 */
PingScheduler::~PingScheduler()
{
}

void PingScheduler::stop_pinging()
{
    // stop pinger, which will probably call ping_done_handler --> re-new NextPingTimer
    GlobalLogger.debug() << "scheduler: stop pinging" << endl;
    Ping->stop_pinging();
    Resolver->cancel_resolve();

    // now cancel the own timer
    GlobalLogger.debug() << "scheduler: cancel timer" << endl;
    NextPingTimer.cancel();
}

/**
 * @brief Start into infinite loop of calls to ping
 *
 * Does not start yet but set NextPingTimer (possibly to 0), so action starts
 *   when io_service is started
 */
void PingScheduler::start_pinging()
{
    if ( FirstDelay > 0 )
        GlobalLogger.info() << "Delaying first ping by " << FirstDelay << "s";
    else
        GlobalLogger.info() << "Schedule ping as soon as possible";

    (void) NextPingTimer.expires_from_now( seconds( FirstDelay ) );
    NextPingTimer.async_wait( bind( &PingScheduler::ping, this,
                                          boost::asio::placeholders::error ) );
}


/**
 * @brief call Ping::ping and schedule a call to ping_done_handler when finished
 */
void PingScheduler::ping(const boost::system::error_code &error)
{
    if ( error )
    {   // get here, e.g. by NextPingTimer.cancel in stop_pinging
        if ( error ==  boost::asio::error::operation_aborted )
            GlobalLogger.error() << "Timer for ping was cancelled! "
                                 << "Stopping" << endl;
        else
            GlobalLogger.error() << "Received error " << error
                                 << " waiting for ping! Stopping"
                                 << endl;
        return;
    }

    // ping as soon as dns is ready
    WantToPing = true;
    ping_when_ready();
}


void PingScheduler::ping_when_ready()
{
    if ( !WantToPing )
    {
        GlobalLogger.info() << "PingScheduler: not pinging (not requested to)";
        return;
    }
    else if ( Resolver && Resolver->is_resolving() )
    {
        GlobalLogger.info() << "PingScheduler: not pinging (DNS not finished)";
        return;
    }
    else if ( !Resolver )
        // should not happen, but check anyway
        GlobalLogger.warning() << LogPrefix << "Have no resolver!";

    GlobalLogger.info() << "PingScheduler: start ping";
    WantToPing = false;

    // try to get an up-to-date IP
    HostAddress ip = Resolver->get_next_ip();

    if ( !ip.is_valid() && ContinueOnOutdatedIps)
    {   // we failed to resolve --> try to use outdated IP
        GlobalLogger.info() << LogPrefix << "Checking for outdated IPs";
        bool check_up_to_date = false;
        ip = Resolver->get_next_ip(check_up_to_date);
    }
    if ( ip.is_valid() )
        Ping->ping(
                Resolver->get_next_ip().get_ip(),
                DestinationPort,
                boost::bind(&PingScheduler::ping_done_handler, this, _1)
        );
    else
    {   // should not happen
        GlobalLogger.error() << LogPrefix << "No IP to ping "
                             << "-- this should not have happened!!";
        WantToPing = true;
        if ( !Resolver->is_resolving() )
            start_resolving_ping_address();
    }

    // next time try with up-to-date IP
    ContinueOnOutdatedIps = false;
}


//------------------------------------------------------------------------------
// Post Processing of Ping result
//------------------------------------------------------------------------------

/**
 * @brief called when Ping::ping is done; calls functions to update
 *   statistics, ping interval and elapsed time;
 *   schedules a call to ping, thereby closing the loop
 */
void PingScheduler::ping_done_handler( const bool ping_success )
{
    // post-processing
    // You must call these 3 methods exactly in this order
    // TODO Fix this method, once it has a semantic dependency with the
    // update_ping_statistics method, because it depends on the PingAnalyzer
    // statistics to update the exceeded_ping_failed_limit
    HostAnalyzer.update_ping_statistics( ping_success );
    update_ping_interval();
    update_ping_elapsed_time();

    // get next protocol, possibly start resolving IPs
    update_ping_protocol();

    // schedule next ping
    (void) NextPingTimer.expires_from_now( seconds( PingIntervalInSec ) );
    NextPingTimer.async_wait( bind( &PingScheduler::ping, this,
                                         boost::asio::placeholders::error ) );
}

void PingScheduler::update_ping_interval()
{
    // have to ping more often?
    if ( HostAnalyzer.exceeded_ping_failed_limit() )
    {
        PingIntervalInSec.speed_up();

        GlobalLogger.debug() << "- Speeding up ping interval to: " << PingIntervalInSec << "s"
                << endl;
    }
    else
    {
        PingIntervalInSec.back_to_original();

        GlobalLogger.debug() << "- Stick to the original ping interval: " << PingIntervalInSec << "s"
                << endl;
    }
}

void PingScheduler::update_ping_elapsed_time()
{
    ptime now = microsec_clock::universal_time();
    time_resolution_traits_adapted64_impl::int_type elapsed_time_in_sec =
            (now - TimeSentLastPing).total_seconds();
    GlobalLogger.debug() << "- Time elapsed since last ping: " << elapsed_time_in_sec << "s" << endl;

    TimeSentLastPing = microsec_clock::universal_time();
}


//------------------------------------------------------------------------------
// Ping Protocol Rotation
//------------------------------------------------------------------------------

void PingScheduler::init_ping_protocol()
{
    ProtocolIter = Protocols.end();
    get_next_ping_protocol();
}

void PingScheduler::update_ping_protocol()
{
    if ( can_change_ping_protocol() )
    {
        get_next_ping_protocol();
    }
}

void PingScheduler::get_next_ping_protocol()
{
    ++ProtocolIter;
    if (ProtocolIter == Protocols.end())
        ProtocolIter = Protocols.begin();
    PingProtocol ping_protocol = *ProtocolIter;
    // --> ProtocolIter still points to currently used protocol which is 
    //     required in dns_resolve_callback

    if (Ping)
        Ping->stop_pinging();

    Ping = PingerFactory::createPinger(ping_protocol, IoService,
                                       NetworkInterfaceName, PingReplyTimeout);

    update_dns_resolver( ping_protocol );
}

bool PingScheduler::can_change_ping_protocol() const
{
    // TODO can_change_ping_protocol() and get_next_ping_protocol() may be implemented in a Algorithm
    // class that can be exchanged in this class to provide an algorithm neutral class
    return true;
}

//------------------------------------------------------------------------------
// DNS host name resolution
//------------------------------------------------------------------------------

// show "!" after host name if running on outdated IPs
void PingScheduler::update_log_prefix()
{
    std::stringstream temp;
    temp << "PS(" << DestinationAddress;
    if (ContinueOnOutdatedIps)
        temp << "!";
    temp << "): ";
    LogPrefix = temp.str();
}

void PingScheduler::update_dns_resolver( PingProtocol current_protocol )
{
    if (Resolver && Resolver->is_resolving())
    {
        GlobalLogger.warning() << "Resolver still seems to be resolving "
                               << "--> cancel!";
        Resolver->cancel_resolve();
    }

    // DNS master caches created resolvers and resolved IPs, so this will
    // probably just return an existing resolver with already resolved IPs for
    // requested protocol ( ICMP/TCP is ignored, only IPv4/v6 is important)
    Resolver = DnsMaster::get_instance()->get_resolver_for(DestinationAddress,
                                                           current_protocol);
    // start resolving if no ips available
    if ( Resolver->have_up_to_date_ip() )
    {
        if (!Resolver->is_resolving())
            GlobalLogger.warning() << "PingScheduler: have up to date IPs but "
                << "resolver seems to be resolving all the same... "
                << "Start pinging anyway!";
        ping_when_ready();
    }
    else
        start_resolving_ping_address();
}

void PingScheduler::start_resolving_ping_address()
{
    Resolver->async_resolve( boost::bind(&PingScheduler::dns_resolve_callback,
                                          this, _1, _2) );
}

void PingScheduler::dns_resolve_callback(const bool was_success,
                                         const int cname_count)
{
    GlobalLogger.info() << "PingScheduler: dns resolution finished "
                        << "with success = " << was_success << " "
                        << "and cname_count = " << cname_count;

    // TODO this is too simple, but need to think more about how to update here!
    // (may have to switch back some time to resolver for original host or so
    ContinueOnOutdatedIps = !was_success;
    update_log_prefix();

    if ( was_success )
    {
        HostAnalyzer.set_resolved_ip_count( Resolver->get_resolved_ip_count());
        ping_when_ready();
    }
    else
    {   // host name resolution failed; try again bypassing first outdated CNAME
        // or using cached IP

        std::string skip_host = Resolver->get_skip_cname();

        if (skip_host.empty())
        {   // continue with IP
            GlobalLogger.notice() << LogPrefix << "DNS failed, "
                << "try anyway with cached data";
            HostAnalyzer.set_resolved_ip_count(0);
            ping_when_ready();
        }
        else
        {   // have CNAME to continue
            GlobalLogger.notice() << LogPrefix << "DNS failed, "
                << "try again skipping a CNAME and resolving "
                << skip_host << " directly";
            Resolver = DnsMaster::get_instance()
                                   ->get_resolver_for(skip_host, *ProtocolIter);
            start_resolving_ping_address();

            // (the original resolver is still alive and cached by DnsMaster and
            //  counting down time to re-try on its own until cancel_resolve)
        }
    }
}