ConfigFileName( "" ),
SourceNetworkInterface( "" ),
NameServer( "" ),
+ Protocol( PingProtocol_ICMP ),
HostsDownLimit( 0 ),
MinHostsDownLimit( 0 ),
MaxHostsDownLimit( 50 ),
SourceNetworkInterface = source_network_interface;
}
+PingProtocol Configuration::get_ping_protocol() const
+{
+ return Protocol;
+}
+
+void Configuration::set_ping_protocol( const PingProtocol ping_protocol )
+{
+ BOOST_ASSERT( ( PingProtocol_First <= ping_protocol ) && ( ping_protocol <= PingProtocol_Last ) );
+
+ Protocol = ping_protocol;
+}
+
int Configuration::get_hosts_down_limit() const
{
return HostsDownLimit;
return LinkUpIntervalInMin;
}
-void Configuration::set_link_up_interval_in_min( const int link_up_interval_in_min )
+void Configuration::set_link_up_interval_in_min(
+ const int link_up_interval_in_min
+)
{
BOOST_ASSERT( ( MinStableLinkIntervalInMin <= link_up_interval_in_min ) && ( link_up_interval_in_min <= MaxStableLinkIntervalInMin ) );
return LinkDownIntervalInMin;
}
-void Configuration::set_link_down_interval_in_min( const int link_down_interval_in_min )
+void Configuration::set_link_down_interval_in_min(
+ const int link_down_interval_in_min
+)
{
BOOST_ASSERT( ( MinStableLinkIntervalInMin <= link_down_interval_in_min ) && ( link_down_interval_in_min <= MaxStableLinkIntervalInMin ) );
#include <boost/shared_ptr.hpp>
#include "config/host.h"
+#include "host/pingprotocol.h"
//-----------------------------------------------------------------------------
// Configuration
const std::string &source_network_interface
);
+ PingProtocol get_ping_protocol() const;
+ void set_ping_protocol( const PingProtocol ping_protocol );
+
int get_hosts_down_limit() const;
void set_hosts_down_limit( const int hosts_down_limit );
std::string ConfigFileName;
std::string SourceNetworkInterface;
std::string NameServer;
+ PingProtocol Protocol;
int HostsDownLimit;
int MinHostsDownLimit;
int MaxHostsDownLimit;
DefaultNameServer( "127.0.0.1" ),
NameServerCmdStr( "nameserver" ),
NameServerCmdDesc( "The local address from where the DNS query will be made." ),
+ PingProtocolCmdStr( "ping-protocol" ),
+ PingProtocolCmdDesc( "Defines which protocol will be used to ping the destination." ),
DefaultHostsDownLimit( 0 ), // no host down
HostsDownLimitCmdStr( "hosts-down-limit" ),
HostsDownLimitCmdDesc( "Limit of host that have to be down in order to notify." ),
options.add_options()
( SourceNetworkInterfaceCmdStr.c_str(), value<string>(), SourceNetworkInterfaceCmdDesc.c_str() )
( NameServerCmdStr.c_str(), value<string>()->default_value( DefaultNameServer ), NameServerCmdDesc.c_str() )
+ ( PingProtocolCmdStr.c_str(), value<string>(), PingProtocolCmdDesc.c_str() )
( HostsDownLimitCmdStr.c_str(), value<int>()->default_value( DefaultHostsDownLimit ), HostsDownLimitCmdDesc.c_str() )
( PingFailLimitCmdStr.c_str(), value<int>()->default_value( DefaultPingFailLimit ), PingFailLimitCmdDesc.c_str() )
( StatusNotifierCmdCmdStr.c_str(), value<string>(), StatusNotifierCmdCmdDesc.c_str() )
<< nameserver << endl;
}
+ // ping-protocol
+ if ( vm.count( PingProtocolCmdStr ) > 0 )
+ {
+ string protocol_string = vm[ PingProtocolCmdStr ].as<string> ();
+ PingProtocol protocol = get_ping_protocol_from_string( protocol_string );
+ Config.set_ping_protocol( protocol );
+
+ GlobalLogger.info() << PingProtocolCmdStr << "="
+ << protocol_string << endl;
+ }
+
// hosts-down-limit
int host_down_limit = 0;
if ( vm.count( HostsDownLimitCmdStr ) > 0 )
const std::string DefaultNameServer;
const std::string NameServerCmdStr;
const std::string NameServerCmdDesc;
+ const std::string PingProtocolCmdStr;
+ const std::string PingProtocolCmdDesc;
const int DefaultHostsDownLimit;
const std::string HostsDownLimitCmdStr;
const std::string HostsDownLimitCmdDesc;