From: Francis Dupont Date: Sat, 16 Nov 2019 21:42:08 +0000 (+0100) Subject: [891-make-stats-mgr-thread-safe] Added thread safety to stats X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=a664a36d4cc03214cc970e7fccfcd26be191f1a8;p=thirdparty%2Fkea.git [891-make-stats-mgr-thread-safe] Added thread safety to stats --- diff --git a/src/lib/stats/context.h b/src/lib/stats/context.h index 9b532e1d36..3e69fb9545 100644 --- a/src/lib/stats/context.h +++ b/src/lib/stats/context.h @@ -1,4 +1,4 @@ -// Copyright (C) 2015 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2015-2019 Internet Systems Consortium, Inc. ("ISC") // // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this @@ -9,6 +9,7 @@ #include #include +#include #include namespace isc { @@ -27,6 +28,9 @@ public: /// related to a given context together. Two examples of such contexts are /// all statistics related to a given subnet or all statistics related to a /// given network interface. +/// +/// When multi-threading is enabled the mutex must be held for any use of +/// a method or the stats_ map. struct StatContext { public: @@ -53,6 +57,11 @@ struct StatContext { /// could make it protected and then return a pointer to it, but that /// would defeat the purpose of the hermetization in the first place. std::map stats_; + + /// @brief The mutex to protect concurrent access when multi-threading + /// is enabled. + std::mutex mutex_; + }; /// @brief Pointer to the statistics context diff --git a/src/lib/stats/stats_mgr.cc b/src/lib/stats/stats_mgr.cc index 25ad50086f..4dc14b45b5 100644 --- a/src/lib/stats/stats_mgr.cc +++ b/src/lib/stats/stats_mgr.cc @@ -11,11 +11,13 @@ #include #include #include +#include #include using namespace std; -using namespace isc::data; using namespace isc::config; +using namespace isc::data; +using namespace isc::util; namespace isc { namespace stats { @@ -31,34 +33,74 @@ StatsMgr::StatsMgr() : } void StatsMgr::setValue(const std::string& name, const int64_t value) { - setValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + setValueInternal(name, value); + } else { + setValueInternal(name, value); + } } void StatsMgr::setValue(const std::string& name, const double value) { - setValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + setValueInternal(name, value); + } else { + setValueInternal(name, value); + } } void StatsMgr::setValue(const std::string& name, const StatsDuration& value) { - setValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + setValueInternal(name, value); + } else { + setValueInternal(name, value); + } } void StatsMgr::setValue(const std::string& name, const std::string& value) { - setValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + setValueInternal(name, value); + } else { + setValueInternal(name, value); + } } void StatsMgr::addValue(const std::string& name, const int64_t value) { - addValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + addValueInternal(name, value); + } else { + addValueInternal(name, value); + } } void StatsMgr::addValue(const std::string& name, const double value) { - addValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + addValueInternal(name, value); + } else { + addValueInternal(name, value); + } } void StatsMgr::addValue(const std::string& name, const StatsDuration& value) { - addValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + addValueInternal(name, value); + } else { + addValueInternal(name, value); + } } void StatsMgr::addValue(const std::string& name, const std::string& value) { - addValueInternal(name, value); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + addValueInternal(name, value); + } else { + addValueInternal(name, value); + } } ObservationPtr StatsMgr::getObservation(const std::string& name) const { @@ -67,6 +109,15 @@ ObservationPtr StatsMgr::getObservation(const std::string& name) const { return (global_->get(name)); } +ObservationPtr StatsMgr::testGetObservation(const std::string& name) const { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (getObservation(name)); + } else { + return (getObservation(name)); + } +} + void StatsMgr::addObservation(const ObservationPtr& stat) { /// @todo: Implement contexts. // Currently we keep everything in a global context. @@ -79,8 +130,8 @@ bool StatsMgr::deleteObservation(const std::string& name) { return (global_->del(name)); } -bool StatsMgr::setMaxSampleAge(const std::string& name, - const StatsDuration& duration) { +bool StatsMgr::setMaxSampleAgeInternal(const std::string& name, + const StatsDuration& duration) { ObservationPtr obs = getObservation(name); if (obs) { obs->setMaxSampleAge(duration); @@ -90,8 +141,18 @@ bool StatsMgr::setMaxSampleAge(const std::string& name, } } -bool StatsMgr::setMaxSampleCount(const std::string& name, - uint32_t max_samples) { +bool StatsMgr::setMaxSampleAge(const std::string& name, + const StatsDuration& duration) { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (setMaxSampleAgeInternal(name, duration)); + } else { + return (setMaxSampleAgeInternal(name, duration)); + } +} + +bool StatsMgr::setMaxSampleCountInternal(const std::string& name, + uint32_t max_samples) { ObservationPtr obs = getObservation(name); if (obs) { obs->setMaxSampleCount(max_samples); @@ -101,7 +162,17 @@ bool StatsMgr::setMaxSampleCount(const std::string& name, } } -void StatsMgr::setMaxSampleAgeAll(const StatsDuration& duration) { +bool StatsMgr::setMaxSampleCount(const std::string& name, + uint32_t max_samples) { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (setMaxSampleCountInternal(name, max_samples)); + } else { + return (setMaxSampleCountInternal(name, max_samples)); + } +} + +void StatsMgr::setMaxSampleAgeAllInternal(const StatsDuration& duration) { // Let's iterate over all stored statistics... for (std::map::iterator s = global_->stats_.begin(); s != global_->stats_.end(); ++s) { @@ -111,7 +182,16 @@ void StatsMgr::setMaxSampleAgeAll(const StatsDuration& duration) { } } -void StatsMgr::setMaxSampleCountAll(uint32_t max_samples) { +void StatsMgr::setMaxSampleAgeAll(const StatsDuration& duration) { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (setMaxSampleAgeAllInternal(duration)); + } else { + return (setMaxSampleAgeAllInternal(duration)); + } +} + +void StatsMgr::setMaxSampleCountAllInternal(uint32_t max_samples) { // Let's iterate over all stored statistics... for (std::map::iterator s = global_->stats_.begin(); s != global_->stats_.end(); ++s) { @@ -121,7 +201,16 @@ void StatsMgr::setMaxSampleCountAll(uint32_t max_samples) { } } -bool StatsMgr::reset(const std::string& name) { +void StatsMgr::setMaxSampleCountAll(uint32_t max_samples) { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (setMaxSampleCountAllInternal(max_samples)); + } else { + return (setMaxSampleCountAllInternal(max_samples)); + } +} + +bool StatsMgr::resetInternal(const std::string& name) { ObservationPtr obs = getObservation(name); if (obs) { obs->reset(); @@ -131,37 +220,74 @@ bool StatsMgr::reset(const std::string& name) { } } +bool StatsMgr::reset(const std::string& name) { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (resetInternal(name)); + } else { + return (resetInternal(name)); + } +} + bool StatsMgr::del(const std::string& name) { - return (global_->del(name)); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (global_->del(name)); + } else { + return (global_->del(name)); + } } void StatsMgr::removeAll() { - global_->stats_.clear(); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + global_->stats_.clear(); + } else { + global_->stats_.clear(); + } } -isc::data::ConstElementPtr StatsMgr::get(const std::string& name) const { - isc::data::ElementPtr response = isc::data::Element::createMap(); // a map +void StatsMgr::getInternal(const std::string& name, + ElementPtr& response) const { ObservationPtr obs = getObservation(name); if (obs) { response->set(name, obs->getJSON()); // that contains observations } - return (response); } -isc::data::ConstElementPtr StatsMgr::getAll() const { - isc::data::ElementPtr map = isc::data::Element::createMap(); // a map +isc::data::ConstElementPtr StatsMgr::get(const std::string& name) const { + isc::data::ElementPtr response = isc::data::Element::createMap(); // a map + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + getInternal(name, response); + } else { + getInternal(name, response); + } + return (response); +} +void StatsMgr::getAllInternal(ElementPtr& response) const { // Let's iterate over all stored statistics... for (std::map::iterator s = global_->stats_.begin(); s != global_->stats_.end(); ++s) { // ... and add each of them to the map. - map->set(s->first, s->second->getJSON()); + response->set(s->first, s->second->getJSON()); } - return (map); } -void StatsMgr::resetAll() { +isc::data::ConstElementPtr StatsMgr::getAll() const { + isc::data::ElementPtr response = isc::data::Element::createMap(); // a map + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + getAllInternal(response); + } else { + getAllInternal(response); + } + return (response); +} + +void StatsMgr::resetAllInternal() { // Let's iterate over all stored statistics... for (std::map::iterator s = global_->stats_.begin(); s != global_->stats_.end(); ++s) { @@ -171,7 +297,16 @@ void StatsMgr::resetAll() { } } -size_t StatsMgr::getSize(const std::string& name) const { +void StatsMgr::resetAll() { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + resetAllInternal(); + } else { + resetAllInternal(); + } +} + +size_t StatsMgr::getSizeInternal(const std::string& name) const { ObservationPtr obs = getObservation(name); size_t size = 0; if (obs) { @@ -180,8 +315,22 @@ size_t StatsMgr::getSize(const std::string& name) const { return (size); } +size_t StatsMgr::getSize(const std::string& name) const { + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (getSizeInternal(name)); + } else { + return (getSizeInternal(name)); + } +} + size_t StatsMgr::count() const { - return (global_->stats_.size()); + if (MultiThreadingMgr::instance().getMode()) { + std::lock_guard lock(global_->mutex_); + return (global_->stats_.size()); + } else { + return (global_->stats_.size()); + } } isc::data::ConstElementPtr diff --git a/src/lib/stats/stats_mgr.h b/src/lib/stats/stats_mgr.h index 450d65a63b..d2df9c97fe 100644 --- a/src/lib/stats/stats_mgr.h +++ b/src/lib/stats/stats_mgr.h @@ -140,7 +140,7 @@ class StatsMgr : public boost::noncopyable { /// @return true if successful, false if there's no such statistic /// Example: /// To set a statistic to keep observations for the last 5 minutes, call: - /// setMaxSampleAge("incoming-packets", time_duration(0, 5, 0, 0)); + /// setMaxSampleAge~("incoming-packets", time_duration(0, 5, 0, 0)); /// to revert statistic to a single value, call: /// setMaxSampleAge("incoming-packets", time_duration(0, 0, 0, 0)); bool setMaxSampleAge(const std::string& name, const StatsDuration& duration); @@ -161,9 +161,13 @@ class StatsMgr : public boost::noncopyable { bool setMaxSampleCount(const std::string& name, uint32_t max_samples); /// @brief Set duration limit for all collected statistics. + /// + /// @param duration determines maximum age of samples void setMaxSampleAgeAll(const StatsDuration& duration); /// @brief Set count limit for all collected statistics. + /// + /// @param max_samples how many samples of a given statistic should be kept void setMaxSampleCountAll(uint32_t max_samples); /// @} @@ -217,13 +221,6 @@ class StatsMgr : public boost::noncopyable { /// @} - /// @brief Returns an observation. - /// - /// Used in testing only. Production code should use @ref get() method. - /// @param name name of the statistic - /// @return Pointer to the Observation object - ObservationPtr getObservation(const std::string& name) const; - /// @brief Generates statistic name in a given context /// /// Example: @@ -426,6 +423,11 @@ class StatsMgr : public boost::noncopyable { /// @} + /// @brief Returns an observation (test only). + /// + /// Used in testing only. Production code should use @ref get() method. + ObservationPtr testGetObservation(const std::string& name) const; + private: /// @brief Private constructor. @@ -441,6 +443,8 @@ private: /// specified by value. This internal method is used by public @ref setValue /// methods. /// + /// Called with the mutex held when multi-threading is enabled. + /// /// @tparam DataType one of int64_t, double, StatsDuration or string /// @param name name of the statistic /// @param value specified statistic will be set to this value @@ -466,6 +470,8 @@ private: /// by name to a value). This internal method is used by public @ref setValue /// methods. /// + /// Called with the mutex held when multi-threading is enabled. + /// /// @tparam DataType one of int64_t, double, StatsDuration or string /// @param name name of the statistic /// @param value specified statistic will be set to this value @@ -490,8 +496,20 @@ private: /// @public + /// @brief Returns an observation. + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param name name of the statistic + /// @return Pointer to the Observation object + ObservationPtr getObservation(const std::string& name) const; + + /// @public + /// @brief Adds a new observation. /// + /// Called with the mutex held when multi-threading is enabled. + /// /// That's an utility method used by public @ref setValue() and /// @ref addValue() methods. /// @param stat observation @@ -501,6 +519,8 @@ private: /// @brief Tries to delete an observation. /// + /// Called with the mutex held when multi-threading is enabled. + /// /// @param name of the statistic to be deleted /// @return true if deleted, false if not found bool deleteObservation(const std::string& name); @@ -560,6 +580,89 @@ private: uint32_t& max_samples, std::string& reason); + /// @brief Determines maximum age of samples (internal version). + /// + /// Specifies that statistic name should be stored not as a single value, + /// but rather as a set of values. duration determines the timespan. + /// Samples older than duration will be discarded. This is time-constrained + /// approach. For sample count constrained approach, see @ref + /// setMaxSampleCount() below. + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param name name of the observation + /// @param duration determines maximum age of samples + /// @return true if successful, false if there's no such statistic + bool setMaxSampleAgeInternal(const std::string& name, + const StatsDuration& duration); + + /// @brief Determines how many samples of a given statistic should be kept + /// (internal version). + /// + /// Specifies that statistic name should be stored not as single value, but + /// rather as a set of values. In this form, at most max_samples will be kept. + /// When adding max_samples + 1 sample, the oldest sample will be discarded. + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param name name of the observation + /// @param max_samples how many samples of a given statistic should be kept + /// @return true if successful, false if there's no such statistic + bool setMaxSampleCountInternal(const std::string& name, + uint32_t max_samples); + + /// @brief Set duration limit for all collected statistics (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param duration determines maximum age of samples + void setMaxSampleAgeAllInternal(const StatsDuration& duration); + + /// @brief Set count limit for all collected statistics (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param max_samples how many samples of a given statistic should be kept + void setMaxSampleCountAllInternal(uint32_t max_samples); + + /// @brief Resets specified statistic (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param name name of the statistic to be reset. + /// @return true if successful, false if there's no such statistic + bool resetInternal(const std::string& name); + + /// @brief Resets all collected statistics back to zero (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + void resetAllInternal(); + + /// @brief Returns size of specified statistic (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param name name of the statistic which size should be return. + /// @return size of specified statistic, 0 means lack of given statistic. + size_t getSizeInternal(const std::string& name) const; + + /// @brief Returns a single statistic as a JSON structure (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param name name of the statistic to get. + /// @param response JSON structures representing a single statistic + void getInternal(const std::string& name, + isc::data::ElementPtr& response) const; + + /// @brief Returns all statistics as a JSON structure (internal version). + /// + /// Called with the mutex held when multi-threading is enabled. + /// + /// @param response JSON structures representing allstatistics + void getAllInternal(isc::data::ElementPtr& response) const; + // This is a global context. All statistics will initially be stored here. StatContextPtr global_; }; diff --git a/src/lib/stats/tests/stats_mgr_unittest.cc b/src/lib/stats/tests/stats_mgr_unittest.cc index 952b1b8c22..ac09e00c69 100644 --- a/src/lib/stats/tests/stats_mgr_unittest.cc +++ b/src/lib/stats/tests/stats_mgr_unittest.cc @@ -62,7 +62,7 @@ TEST_F(StatsMgrTest, integerStat) { static_cast(1234))); ObservationPtr alpha; - EXPECT_NO_THROW(alpha = StatsMgr::instance().getObservation("alpha")); + EXPECT_NO_THROW(alpha = StatsMgr::instance().testGetObservation("alpha")); ASSERT_TRUE(alpha); std::string exp = "{ \"alpha\": [ [ 1234, \"" + @@ -77,7 +77,7 @@ TEST_F(StatsMgrTest, floatStat) { EXPECT_NO_THROW(StatsMgr::instance().setValue("beta", 12.34)); ObservationPtr beta; - EXPECT_NO_THROW(beta = StatsMgr::instance().getObservation("beta")); + EXPECT_NO_THROW(beta = StatsMgr::instance().testGetObservation("beta")); ASSERT_TRUE(beta); std::string exp = "{ \"beta\": [ [ 12.34, \"" + @@ -93,7 +93,7 @@ TEST_F(StatsMgrTest, durationStat) { microsec::time_duration(1, 2, 3, 4))); ObservationPtr gamma; - EXPECT_NO_THROW(gamma = StatsMgr::instance().getObservation("gamma")); + EXPECT_NO_THROW(gamma = StatsMgr::instance().testGetObservation("gamma")); ASSERT_TRUE(gamma); std::string exp = "{ \"gamma\": [ [ \"01:02:03.000004\", \"" + @@ -109,7 +109,7 @@ TEST_F(StatsMgrTest, stringStat) { "Lorem ipsum")); ObservationPtr delta; - EXPECT_NO_THROW(delta = StatsMgr::instance().getObservation("delta")); + EXPECT_NO_THROW(delta = StatsMgr::instance().testGetObservation("delta")); ASSERT_TRUE(delta); std::string exp = "{ \"delta\": [ [ \"Lorem ipsum\", \"" + @@ -174,45 +174,45 @@ TEST_F(StatsMgrTest, setLimitsAll) { EXPECT_NO_THROW(StatsMgr::instance().setMaxSampleAgeAll(time_duration(0, 0, 1, 0))); // check if time limit was set properly and whether count limit is disabled - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().second, time_duration(0, 0, 1, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().second, time_duration(0, 0, 1, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().second, time_duration(0, 0, 1, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().second, time_duration(0, 0, 1, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, false); // check the setting of count limit to existing statistics EXPECT_NO_THROW(StatsMgr::instance().setMaxSampleCountAll(1200)); // check if count limit was set properly and whether count limit is disabled - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 1200); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().second, 1200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().second, 1200); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().second, 1200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().second, 1200); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().second, 1200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().second, 1200); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().second, 1200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, false); } // This test checks whether a single (get("foo")) and all (getAll()) @@ -226,16 +226,16 @@ TEST_F(StatsMgrTest, getGetAll) { // The string's representation of firstly added statistics std::string alpha_first = ", [ 1234, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha") ->getInteger().second) + "\" ] ]"; std::string beta_first = ", [ 12.34, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("beta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta") ->getFloat().second) + "\" ] ]"; std::string gamma_first = ", [ \"01:02:03.000004\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma") ->getDuration().second) + "\" ] ]"; std::string delta_first = ", [ \"Lorem\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("delta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta") ->getString().second) + "\" ] ]"; // Now add some values to them @@ -259,16 +259,16 @@ TEST_F(StatsMgrTest, getGetAll) { ASSERT_TRUE(rep_delta); std::string exp_str_alpha = "[ [ 6912, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha") ->getInteger().second) + "\" ]" + alpha_first; std::string exp_str_beta = "[ [ 69.12, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("beta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta") ->getFloat().second) + "\" ]" + beta_first; std::string exp_str_gamma = "[ [ \"06:08:10.000012\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma") ->getDuration().second) + "\" ]" + gamma_first; std::string exp_str_delta = "[ [ \"Lorem ipsum\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("delta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta") ->getString().second) + "\" ]" + delta_first; // Check that individual stats are reported properly @@ -310,26 +310,26 @@ TEST_F(StatsMgrTest, reset) { // This should reset alpha to 0 EXPECT_NO_THROW(StatsMgr::instance().reset("alpha")); EXPECT_EQ(0, - StatsMgr::instance().getObservation("alpha")->getInteger().first); + StatsMgr::instance().testGetObservation("alpha")->getInteger().first); // The other stats should remain untouched EXPECT_EQ(12.34, - StatsMgr::instance().getObservation("beta")->getFloat().first); + StatsMgr::instance().testGetObservation("beta")->getFloat().first); EXPECT_EQ(time_duration(1, 2, 3, 4), - StatsMgr::instance().getObservation("gamma")->getDuration().first); + StatsMgr::instance().testGetObservation("gamma")->getDuration().first); EXPECT_EQ("Lorem ipsum", - StatsMgr::instance().getObservation("delta")->getString().first); + StatsMgr::instance().testGetObservation("delta")->getString().first); // Now let's wipe them, too. EXPECT_NO_THROW(StatsMgr::instance().reset("beta")); EXPECT_NO_THROW(StatsMgr::instance().reset("gamma")); EXPECT_NO_THROW(StatsMgr::instance().reset("delta")); EXPECT_EQ(0.0, - StatsMgr::instance().getObservation("beta")->getFloat().first); + StatsMgr::instance().testGetObservation("beta")->getFloat().first); EXPECT_EQ(time_duration(0, 0, 0, 0), - StatsMgr::instance().getObservation("gamma")->getDuration().first); + StatsMgr::instance().testGetObservation("gamma")->getDuration().first); EXPECT_EQ("", - StatsMgr::instance().getObservation("delta")->getString().first); + StatsMgr::instance().testGetObservation("delta")->getString().first); // Resetting statistics should not remove them EXPECT_EQ(4, StatsMgr::instance().count()); @@ -346,13 +346,13 @@ TEST_F(StatsMgrTest, resetAll) { // This should reset alpha to 0 EXPECT_NO_THROW(StatsMgr::instance().resetAll()); EXPECT_EQ(0, - StatsMgr::instance().getObservation("alpha")->getInteger().first); + StatsMgr::instance().testGetObservation("alpha")->getInteger().first); EXPECT_EQ(0.0, - StatsMgr::instance().getObservation("beta")->getFloat().first); + StatsMgr::instance().testGetObservation("beta")->getFloat().first); EXPECT_EQ(time_duration(0, 0, 0, 0), - StatsMgr::instance().getObservation("gamma")->getDuration().first); + StatsMgr::instance().testGetObservation("gamma")->getDuration().first); EXPECT_EQ("", - StatsMgr::instance().getObservation("delta")->getString().first); + StatsMgr::instance().testGetObservation("delta")->getString().first); // Resetting all statistics should not remove them EXPECT_EQ(4, StatsMgr::instance().count()); @@ -379,10 +379,10 @@ TEST_F(StatsMgrTest, removeAll) { EXPECT_EQ("{ }", StatsMgr::instance().get("delta")->str()); // There should be no such statistics anymore - EXPECT_FALSE(StatsMgr::instance().getObservation("alpha")); - EXPECT_FALSE(StatsMgr::instance().getObservation("beta")); - EXPECT_FALSE(StatsMgr::instance().getObservation("gamma")); - EXPECT_FALSE(StatsMgr::instance().getObservation("delta")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("alpha")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("beta")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("gamma")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("delta")); } // This is a performance benchmark that checks how long does it take @@ -516,7 +516,7 @@ TEST_F(StatsMgrTest, commandStatisticGet) { params); ObservationPtr alpha; - EXPECT_NO_THROW(alpha = StatsMgr::instance().getObservation("alpha")); + EXPECT_NO_THROW(alpha = StatsMgr::instance().testGetObservation("alpha")); ASSERT_TRUE(alpha); std::string exp = "{ \"alpha\": [ [ 1234, \"" + @@ -570,16 +570,16 @@ TEST_F(StatsMgrTest, commandGetAll) { ASSERT_TRUE(rep_delta); std::string exp_str_alpha = "[ [ 1234, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha") ->getInteger().second) + "\" ] ]"; std::string exp_str_beta = "[ [ 12.34, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("beta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta") ->getFloat().second) + "\" ] ]"; std::string exp_str_gamma = "[ [ \"01:02:03.000004\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma") ->getDuration().second) + "\" ] ]"; std::string exp_str_delta = "[ [ \"Lorem ipsum\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("delta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta") ->getString().second) + "\" ] ]"; // Check that all of them can be reported at once @@ -620,7 +620,7 @@ TEST_F(StatsMgrTest, commandStatisticReset) { EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code); ObservationPtr alpha; - EXPECT_NO_THROW(alpha = StatsMgr::instance().getObservation("alpha")); + EXPECT_NO_THROW(alpha = StatsMgr::instance().testGetObservation("alpha")); ASSERT_TRUE(alpha); // Check that it was indeed reset @@ -673,16 +673,16 @@ TEST_F(StatsMgrTest, commandResetAll) { ASSERT_TRUE(rep_delta); std::string exp_str_alpha = "[ [ 1234, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha") ->getInteger().second) + "\" ] ]"; std::string exp_str_beta = "[ [ 12.34, \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("beta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta") ->getFloat().second) + "\" ] ]"; std::string exp_str_gamma = "[ [ \"01:02:03.000004\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma") ->getDuration().second) + "\" ] ]"; std::string exp_str_delta = "[ [ \"Lorem ipsum\", \"" + - isc::util::ptimeToText(StatsMgr::instance().getObservation("delta") + isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta") ->getString().second) + "\" ] ]"; // Check that all of them can be reset at once @@ -696,13 +696,13 @@ TEST_F(StatsMgrTest, commandResetAll) { // Check that they're indeed reset EXPECT_EQ(0, - StatsMgr::instance().getObservation("alpha")->getInteger().first); + StatsMgr::instance().testGetObservation("alpha")->getInteger().first); EXPECT_EQ(0.0f, - StatsMgr::instance().getObservation("beta")->getFloat().first); + StatsMgr::instance().testGetObservation("beta")->getFloat().first); EXPECT_EQ(time_duration(0, 0, 0, 0), - StatsMgr::instance().getObservation("gamma")->getDuration().first); + StatsMgr::instance().testGetObservation("gamma")->getDuration().first); EXPECT_EQ("", - StatsMgr::instance().getObservation("delta")->getString().first); + StatsMgr::instance().testGetObservation("delta")->getString().first); } // Test checks if statistic-remove handler is able to remove a statistic. @@ -719,7 +719,7 @@ TEST_F(StatsMgrTest, commandStatisticRemove) { EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code); // It should be gone. - EXPECT_FALSE(StatsMgr::instance().getObservation("alpha")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("alpha")); EXPECT_EQ(0, StatsMgr::instance().count()); } @@ -765,10 +765,10 @@ TEST_F(StatsMgrTest, commandRemoveAll) { ConstElementPtr rep_all = parseAnswer(status_code, rsp); ASSERT_EQ(0, status_code); - EXPECT_FALSE(StatsMgr::instance().getObservation("alpha")); - EXPECT_FALSE(StatsMgr::instance().getObservation("beta")); - EXPECT_FALSE(StatsMgr::instance().getObservation("gamma")); - EXPECT_FALSE(StatsMgr::instance().getObservation("delta")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("alpha")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("beta")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("gamma")); + EXPECT_FALSE(StatsMgr::instance().testGetObservation("delta")); EXPECT_EQ(0, StatsMgr::instance().count()); } @@ -788,10 +788,10 @@ TEST_F(StatsMgrTest, commandSetMaxSampleAge) { EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code); // check if time limit was set properly and whether count limit is disabled - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().second, time_duration(0, 20, 45, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, false); } // Test checks if statistic-sample-age-set is able to handle: @@ -845,25 +845,25 @@ TEST_F(StatsMgrTest, commandSetMaxSampleAgeAll) { EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code); // check if time limit was set properly and whether count limit is disabled - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().second, time_duration(1, 2, 45, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().second, time_duration(1, 2, 45, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().second, time_duration(1, 2, 45, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().second, + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().second, time_duration(1, 2, 45, 0)); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, false); } // This test checks whether statistic-sample-count-set command really set @@ -882,9 +882,9 @@ TEST_F(StatsMgrTest, commandSetMaxSampleCount) { EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code); // check if time limit was set properly and whether duration limit is disabled - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 15); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().second, 15); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, false); } // Test checks if statistic-sample-count-set is able to handle: @@ -938,21 +938,21 @@ TEST_F(StatsMgrTest, commandSetMaxSampleCountAll) { EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code); // check if count limit was set properly and whether count limit is disabled - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 200); - EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().second, 200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().second, 200); - EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().second, 200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().second, 200); - EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().second, 200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, false); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, true); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().second, 200); - EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, true); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().second, 200); + EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, false); } };