Included the unit in the variable names

- states clear that we expect seconds, minutes or whatever

diff --git a/src/config/configuration.cpp b/src/config/configuration.cpp
index b0ca229..baa2425 100644 (file)
--- a/src/config/configuration.cpp
+++ b/src/config/configuration.cpp
@@ -17,9 +17,9 @@ Configuration::Configuration() :
     MinPingFailLimit( 0 ),
     MaxPingFailLimit( 100 ),
     StatusNotifierCmd( "" ),
-    LinkUpInterval( 0 ),
-    MinStableLinkInterval( 0 ),
-    MaxStableLinkInterval( 60 ),
+    LinkUpIntervalInMin( 0 ),
+    MinStableLinkIntervalInMin( 0 ),
+    MaxStableLinkIntervalInMin( 60 ),
     Hosts()
 {
 }
@@ -76,16 +76,16 @@ void Configuration::set_status_notifier_cmd( const string &status_notifier_cmd )
     StatusNotifierCmd = status_notifier_cmd;
 }
 
-int Configuration::get_link_up_interval() const
+int Configuration::get_link_up_interval_in_min() const
 {
-    return LinkUpInterval;
+    return LinkUpIntervalInMin;
 }
 
-void Configuration::set_link_up_interval( const int link_up_interval )
+void Configuration::set_link_up_interval_in_min( const int link_up_interval_in_min )
 {
-    BOOST_ASSERT( ( MinStableLinkInterval <= link_up_interval ) && ( link_up_interval <= MaxStableLinkInterval ) );
+    BOOST_ASSERT( ( MinStableLinkIntervalInMin <= link_up_interval_in_min ) && ( link_up_interval_in_min <= MaxStableLinkIntervalInMin ) );
 
-    LinkUpInterval = link_up_interval;
+    LinkUpIntervalInMin = link_up_interval_in_min;
 }
 
 vector< HostItem > Configuration::get_hosts() const

diff --git a/src/config/configuration.h b/src/config/configuration.h
index 0bb273f..1d8d0d3 100644 (file)
--- a/src/config/configuration.h
+++ b/src/config/configuration.h
@@ -30,8 +30,8 @@ public:
     std::string get_status_notifier_cmd() const;
     void set_status_notifier_cmd( const std::string &status_notifier_cmd );
 
-    int get_link_up_interval() const;
-    void set_link_up_interval( const int link_up_interval );
+    int get_link_up_interval_in_min() const;
+    void set_link_up_interval_in_min( const int link_up_interval_in_min );
 
     std::vector<HostItem> get_hosts() const;
     void set_hosts( const std::vector<HostItem> &hosts_list );
@@ -45,9 +45,9 @@ private:
     const int MinPingFailLimit;
     const int MaxPingFailLimit;
     std::string StatusNotifierCmd;
-    int LinkUpInterval;
-    const int MinStableLinkInterval;
-    const int MaxStableLinkInterval;
+    int LinkUpIntervalInMin;
+    const int MinStableLinkIntervalInMin;
+    const int MaxStableLinkIntervalInMin;
     std::vector<HostItem> Hosts;
 
 };

diff --git a/src/config/configurationreader.cpp b/src/config/configurationreader.cpp
index 08e9d22..8c78ba4 100644 (file)
--- a/src/config/configurationreader.cpp
+++ b/src/config/configurationreader.cpp
@@ -31,12 +31,12 @@ ConfigurationReader::ConfigurationReader() :
     PingFailLimitCmdDesc( "Maximum percentage of pings that can fail for a given host." ),
     StatusNotifierCmdCmdStr( "status-notifier-cmd" ),
     StatusNotifierCmdCmdDesc( "The command to execute to alert about host status." ),
-    DefaultLinkUpInterval( 5 ), // 5 minutes
+    DefaultLinkUpIntervalInMin( 5 ), // 5 minutes
     LinkUpIntervalCmdStr( "link-up-interval" ),
     LinkUpIntervalCmdDesc( "How long the link must be responsive in order to consider it stable." ),
     HostNameCmdStr( "host.name" ),
     HostNameCmdDesc( "Host address" ),
-    DefaultHostInterval( 60 ), // 60 seconds
+    DefaultHostIntervalInSec( 60 ), // 60 seconds
     HostIntervalCmdStr( "host.interval" ),
     HostIntervalCmdDesc( "Interval between each ping to the host" )
 {
@@ -120,7 +120,7 @@ options_description ConfigurationReader::get_configuration_options() const
         ( 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() )
-        ( LinkUpIntervalCmdStr.c_str(), value<int>()->default_value( DefaultLinkUpInterval ), LinkUpIntervalCmdDesc.c_str() )
+        ( LinkUpIntervalCmdStr.c_str(), value<int>()->default_value( DefaultLinkUpIntervalInMin ), LinkUpIntervalCmdDesc.c_str() )
         ( HostNameCmdStr.c_str(), value< vector<string> >(), HostNameCmdDesc.c_str() )
         ( HostIntervalCmdStr.c_str(), value< vector<int> >(), HostIntervalCmdDesc.c_str() )
     ;
@@ -170,10 +170,10 @@ bool ConfigurationReader::parse_configuration_options( const variables_map &vm )
     // link-up-interval
     if ( vm.count( LinkUpIntervalCmdStr ) )
     {
-        int link_up_interval = vm[ LinkUpIntervalCmdStr ].as<int>();
-        Config.set_link_up_interval( link_up_interval );
+        int link_up_interval_in_min = vm[ LinkUpIntervalCmdStr ].as<int>();
+        Config.set_link_up_interval_in_min( link_up_interval_in_min );
 
-        cout << LinkUpIntervalCmdStr << "=" << link_up_interval
+        cout << LinkUpIntervalCmdStr << "=" << link_up_interval_in_min
              << endl;
     }
 
@@ -207,19 +207,19 @@ bool ConfigurationReader::parse_configuration_options( const variables_map &vm )
         vector<HostItem>::iterator hosts_it = hosts_list.begin();
 
         vector<int> hosts_intervals = vm[ HostIntervalCmdStr ].as< vector<int> > ();
-        BOOST_FOREACH( int host_interval, hosts_intervals )
+        BOOST_FOREACH( int host_interval_in_sec, hosts_intervals )
         {
             HostItem host_item = *hosts_it;
-            host_item->set_interval( host_interval );
+            host_item->set_interval_in_sec( host_interval_in_sec );
             hosts_it++;
 
-            cout << HostIntervalCmdStr << "=" << host_interval << endl;
+            cout << HostIntervalCmdStr << "=" << host_interval_in_sec << endl;
         }
 
         hosts_interval_count = hosts_intervals.size();
     }
 
-    // TODO deal when interval for a given host was not set. use DefaultHostInterval
+    // TODO deal when interval for a given host was not set. use DefaultHostIntervalInSec
 
     BOOST_ASSERT( hosts_names_count == hosts_interval_count );
 

diff --git a/src/config/configurationreader.h b/src/config/configurationreader.h
index a431b5b..d133f0d 100644 (file)
--- a/src/config/configurationreader.h
+++ b/src/config/configurationreader.h
@@ -69,12 +69,12 @@ private:
     const std::string PingFailLimitCmdDesc;
     const std::string StatusNotifierCmdCmdStr;
     const std::string StatusNotifierCmdCmdDesc;
-    const int DefaultLinkUpInterval;
+    const int DefaultLinkUpIntervalInMin;
     const std::string LinkUpIntervalCmdStr;
     const std::string LinkUpIntervalCmdDesc;
     const std::string HostNameCmdStr;
     const std::string HostNameCmdDesc;
-    const int DefaultHostInterval;
+    const int DefaultHostIntervalInSec;
     const std::string HostIntervalCmdStr;
     const std::string HostIntervalCmdDesc;
 

diff --git a/src/config/host.cpp b/src/config/host.cpp
index a92ffd0..498f8bb 100644 (file)
--- a/src/config/host.cpp
+++ b/src/config/host.cpp
@@ -11,7 +11,7 @@
 Host::Host( std::string address ) :
     Address( address ),
     Port( 0 ),
-    Interval( 0 ),
+    IntervalInSec( 0 ),
     Options()
 {
 }
@@ -44,16 +44,16 @@ void Host::set_port( const uint16_t port )
     this->Port = port;
 }
 
-int Host::get_interval() const
+int Host::get_interval_in_sec() const
 {
-    return Interval;
+    return IntervalInSec;
 }
 
-void Host::set_interval( const int interval )
+void Host::set_interval_in_sec( const int interval_in_sec )
 {
-    BOOST_ASSERT( ( 0 < interval ) && ( interval < std::numeric_limits<int>::max() ) );
+    BOOST_ASSERT( ( 0 < interval_in_sec ) && ( interval_in_sec < std::numeric_limits<int>::max() ) );
 
-    this->Interval = interval;
+    this->IntervalInSec = interval_in_sec;
 }
 
 std::vector<std::string> Host::get_options() const

diff --git a/src/config/host.h b/src/config/host.h
index 2485e04..b828934 100644 (file)
--- a/src/config/host.h
+++ b/src/config/host.h
@@ -24,8 +24,8 @@ public:
     uint16_t get_port() const;
     void set_port( const uint16_t port );
 
-    int get_interval() const;
-    void set_interval( const int interval );
+    int get_interval_in_sec() const;
+    void set_interval_in_sec( const int interval_in_sec );
 
     std::vector<std::string> get_options() const;
     void set_options( const std::vector<std::string> &options );
@@ -33,7 +33,7 @@ public:
 private:
     std::string Address;
     uint16_t Port;
-    int Interval;
+    int IntervalInSec;
     std::vector<std::string> Options;
 
 };

diff --git a/src/main.cpp b/src/main.cpp
index 0ff8247..ceb9cfc 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -25,7 +25,7 @@ int main( int argc, char* argv[] )
         Configuration config = config_reader.get_configuration();
 
         int ping_fail_limit = config.get_ping_fail_limit();
-        int link_up_interval = config.get_link_up_interval();
+        int link_up_interval_in_min = config.get_link_up_interval_in_min();
 
         // TODO init_notifier and get_notifier
         int hosts_down_limit = config.get_hosts_down_limit();
@@ -33,7 +33,7 @@ int main( int argc, char* argv[] )
         shared_ptr<LinkStatusAnalyzer> link_analyzer(
                 new LinkStatusAnalyzer(
                         hosts_down_limit,
-                        link_up_interval,
+                        link_up_interval_in_min,
                         status_notifier_cmd
                 )
         );
@@ -44,11 +44,14 @@ int main( int argc, char* argv[] )
         BOOST_FOREACH( HostItem host, hosts )
         {
             string ping_address = (*host).get_address();
-            int ping_interval = (*host).get_interval();
+            int ping_interval_in_sec = (*host).get_interval_in_sec();
             PingSchedulerItem scheduler(
                     new PingScheduler(
-                            io_service, ping_address, ping_interval,
-                            ping_fail_limit, link_analyzer
+                            io_service,
+                            ping_address,
+                            ping_interval_in_sec,
+                            ping_fail_limit,
+                            link_analyzer
                     )
             );
             scheduler_list.push_back( scheduler );