From: Michal 'vorner' Vaner Date: Sat, 13 Oct 2012 09:21:44 +0000 (+0200) Subject: [2207] Rename updater to reloader X-Git-Tag: trac2402_base~12^2~29 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=58c41ea9cdb2df726b4b54015500acab3ae34040;p=thirdparty%2Fkea.git [2207] Rename updater to reloader This might be less confusing. --- diff --git a/src/lib/datasrc/memory/Makefile.am b/src/lib/datasrc/memory/Makefile.am index a4a2a6b820..192bbce965 100644 --- a/src/lib/datasrc/memory/Makefile.am +++ b/src/lib/datasrc/memory/Makefile.am @@ -22,7 +22,7 @@ libdatasrc_memory_la_SOURCES += zone_table.h zone_table.cc libdatasrc_memory_la_SOURCES += zone_finder.h zone_finder.cc libdatasrc_memory_la_SOURCES += zone_table_segment.h zone_table_segment.cc libdatasrc_memory_la_SOURCES += zone_table_segment_local.h zone_table_segment_local.cc -libdatasrc_memory_la_SOURCES += zone_updater.h zone_updater.cc +libdatasrc_memory_la_SOURCES += zone_reloader.h zone_reloader.cc nodist_libdatasrc_memory_la_SOURCES = memory_messages.h memory_messages.cc EXTRA_DIST = rdata_serialization_priv.cc diff --git a/src/lib/datasrc/memory/zone_updater.cc b/src/lib/datasrc/memory/zone_reloader.cc similarity index 80% rename from src/lib/datasrc/memory/zone_updater.cc rename to src/lib/datasrc/memory/zone_reloader.cc index 40d55eeb12..67c6865cb0 100644 --- a/src/lib/datasrc/memory/zone_updater.cc +++ b/src/lib/datasrc/memory/zone_reloader.cc @@ -12,7 +12,7 @@ // OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR // PERFORMANCE OF THIS SOFTWARE. -#include "zone_updater.h" +#include "zone_reloader.h" #include "zone_data.h" #include "zone_table_segment.h" @@ -24,11 +24,11 @@ namespace isc { namespace datasrc { namespace memory { -ZoneUpdaterLocal::ZoneUpdaterLocal(ZoneTableSegment* segment, - const LoadAction& load_action, - const InstallAction& install_action, - const dns::Name& origin, - const dns::RRClass& rrclass) : +ZoneReloaderLocal::ZoneReloaderLocal(ZoneTableSegment* segment, + const LoadAction& load_action, + const InstallAction& install_action, + const dns::Name& origin, + const dns::RRClass& rrclass) : segment_(segment), load_action_(load_action), install_action_(install_action), @@ -39,14 +39,14 @@ ZoneUpdaterLocal::ZoneUpdaterLocal(ZoneTableSegment* segment, data_ready_(false) {} -ZoneUpdaterLocal::~ZoneUpdaterLocal() { +ZoneReloaderLocal::~ZoneReloaderLocal() { // Clean up everything there might be left if someone forgot, just // in case. Or should we assert instead? cleanup(); } void -ZoneUpdaterLocal::load() { +ZoneReloaderLocal::load() { if (loaded_) { isc_throw(isc::Unexpected, "Trying to load twice"); } @@ -60,7 +60,7 @@ ZoneUpdaterLocal::load() { } void -ZoneUpdaterLocal::install() { +ZoneReloaderLocal::install() { if (!data_ready_) { isc_throw(isc::Unexpected, "No data to install"); } @@ -75,7 +75,7 @@ ZoneUpdaterLocal::install() { } void -ZoneUpdaterLocal::cleanup() { +ZoneReloaderLocal::cleanup() { // We eat the data (if any) now. data_ready_ = false; diff --git a/src/lib/datasrc/memory/zone_updater.h b/src/lib/datasrc/memory/zone_reloader.h similarity index 94% rename from src/lib/datasrc/memory/zone_updater.h rename to src/lib/datasrc/memory/zone_reloader.h index 5d445ddbe9..12e84dc0bd 100644 --- a/src/lib/datasrc/memory/zone_updater.h +++ b/src/lib/datasrc/memory/zone_reloader.h @@ -34,7 +34,7 @@ class ZoneTableSegment; /// We divide them so the update of zone data can be done asynchronously, /// in a different thread. The install() operation is the only one that needs /// to be done in a critical section. -class ZoneUpdater { +class ZoneReloader { public: /// \brief Get the zone data into memory. /// @@ -120,13 +120,13 @@ typedef boost::function LoadAction; typedef boost::function InstallAction; -/// \brief Updater implementation which loads data locally. +/// \brief Reloader implementation which loads data locally. /// /// This implementation prepares a clean zone data and lets one callback /// to fill it and another to install it somewhere. The class does mostly /// nothing (and delegates the work to the callbacks), just stores little bit /// of state between the calls. -class ZoneUpdaterLocal : public ZoneUpdater { +class ZoneReloaderLocal : public ZoneReloader { public: /// \brief Constructor /// @@ -135,12 +135,12 @@ public: /// \param install_action The callback used to install the loaded zone. /// \param origin The origin name of the zone. /// \param rrclass The class of the zone. - ZoneUpdaterLocal(ZoneTableSegment* segment, const LoadAction& load_action, - const InstallAction& install_action, - const dns::Name& origin, - const dns::RRClass& rrclass); + ZoneReloaderLocal(ZoneTableSegment* segment, const LoadAction& load_action, + const InstallAction& install_action, + const dns::Name& origin, + const dns::RRClass& rrclass); /// \brief Destructor - ~ZoneUpdaterLocal(); + ~ZoneReloaderLocal(); /// \brief Loads the data. /// /// This prepares an empty ZoneData and calls load_action (passed to diff --git a/src/lib/datasrc/tests/memory/Makefile.am b/src/lib/datasrc/tests/memory/Makefile.am index ba922a648d..5b3d9b5ed2 100644 --- a/src/lib/datasrc/tests/memory/Makefile.am +++ b/src/lib/datasrc/tests/memory/Makefile.am @@ -33,7 +33,7 @@ run_unittests_SOURCES += memory_segment_test.h run_unittests_SOURCES += segment_object_holder_unittest.cc run_unittests_SOURCES += memory_client_unittest.cc run_unittests_SOURCES += zone_table_segment_unittest.cc -run_unittests_SOURCES += zone_updater_unittest.cc +run_unittests_SOURCES += zone_reloader_unittest.cc run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES) run_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS) diff --git a/src/lib/datasrc/tests/memory/zone_updater_unittest.cc b/src/lib/datasrc/tests/memory/zone_reloader_unittest.cc similarity index 72% rename from src/lib/datasrc/tests/memory/zone_updater_unittest.cc rename to src/lib/datasrc/tests/memory/zone_reloader_unittest.cc index c32fb87609..4c71abd472 100644 --- a/src/lib/datasrc/tests/memory/zone_updater_unittest.cc +++ b/src/lib/datasrc/tests/memory/zone_reloader_unittest.cc @@ -12,7 +12,7 @@ // OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR // PERFORMANCE OF THIS SOFTWARE. -#include +#include #include #include @@ -35,33 +35,34 @@ namespace { class TestException {}; -class ZoneUpdaterLocalTest : public ::testing::Test { +class ZoneReloaderLocalTest : public ::testing::Test { public: - ZoneUpdaterLocalTest() : + ZoneReloaderLocalTest() : // FIXME: The NullElement probably isn't the best one, but we don't // know how the config will look, so it just fills the argument // (which is currently ignored) segment_(ZoneTableSegment::create(isc::data::NullElement())), - updater_(new - ZoneUpdaterLocal(segment_.get(), - bind(&ZoneUpdaterLocalTest::loadAction, this, _1), - bind(&ZoneUpdaterLocalTest::installAction, this, - _1, _2), - Name("example.org"), RRClass::IN())), + reloader_(new + ZoneReloaderLocal(segment_.get(), + bind(&ZoneReloaderLocalTest::loadAction, this, + _1), + bind(&ZoneReloaderLocalTest::installAction, this, + _1, _2), + Name("example.org"), RRClass::IN())), load_called_(false), install_called_(false), load_throw_(false), install_throw_(false) {} void TearDown() { - // Release the updater - updater_.reset(); + // Release the reloader + reloader_.reset(); // And check we freed all memory EXPECT_TRUE(segment_->getMemorySegment().allMemoryDeallocated()); } protected: scoped_ptr segment_; - scoped_ptr updater_; + scoped_ptr reloader_; bool load_called_; bool install_called_; bool load_throw_; @@ -106,83 +107,83 @@ private: // We call it the way we are supposed to, check every callback is called in the // right moment. -TEST_F(ZoneUpdaterLocalTest, correctCall) { +TEST_F(ZoneReloaderLocalTest, correctCall) { // Nothing called before we call it EXPECT_FALSE(load_called_); EXPECT_FALSE(install_called_); // Just the load gets called now - EXPECT_NO_THROW(updater_->load()); + EXPECT_NO_THROW(reloader_->load()); EXPECT_TRUE(load_called_); EXPECT_FALSE(install_called_); load_called_ = false; - EXPECT_NO_THROW(updater_->install()); + EXPECT_NO_THROW(reloader_->install()); EXPECT_FALSE(load_called_); EXPECT_TRUE(install_called_); // We don't check explicitly how this works, but call it to free memory. If // everything is freed should be checked inside the TearDown. - EXPECT_NO_THROW(updater_->cleanup()); + EXPECT_NO_THROW(reloader_->cleanup()); } -TEST_F(ZoneUpdaterLocalTest, loadTwice) { +TEST_F(ZoneReloaderLocalTest, loadTwice) { // Load it the first time - EXPECT_NO_THROW(updater_->load()); + EXPECT_NO_THROW(reloader_->load()); EXPECT_TRUE(load_called_); EXPECT_FALSE(install_called_); load_called_ = false; // The second time, it should not be possible - EXPECT_THROW(updater_->load(), isc::Unexpected); + EXPECT_THROW(reloader_->load(), isc::Unexpected); EXPECT_FALSE(load_called_); EXPECT_FALSE(install_called_); // The object should not be damaged, try installing and clearing now - EXPECT_NO_THROW(updater_->install()); + EXPECT_NO_THROW(reloader_->install()); EXPECT_FALSE(load_called_); EXPECT_TRUE(install_called_); // We don't check explicitly how this works, but call it to free memory. If // everything is freed should be checked inside the TearDown. - EXPECT_NO_THROW(updater_->cleanup()); + EXPECT_NO_THROW(reloader_->cleanup()); } // Try loading after call to install and call to cleanup. Both is // forbidden. -TEST_F(ZoneUpdaterLocalTest, loadLater) { +TEST_F(ZoneReloaderLocalTest, loadLater) { // Load first, so we can install - EXPECT_NO_THROW(updater_->load()); - EXPECT_NO_THROW(updater_->install()); + EXPECT_NO_THROW(reloader_->load()); + EXPECT_NO_THROW(reloader_->install()); // Reset so we see nothing is called now install_called_ = load_called_ = false; - EXPECT_THROW(updater_->load(), isc::Unexpected); + EXPECT_THROW(reloader_->load(), isc::Unexpected); EXPECT_FALSE(load_called_); EXPECT_FALSE(install_called_); // Cleanup and try loading again. Still shouldn't work. - EXPECT_NO_THROW(updater_->cleanup()); + EXPECT_NO_THROW(reloader_->cleanup()); - EXPECT_THROW(updater_->load(), isc::Unexpected); + EXPECT_THROW(reloader_->load(), isc::Unexpected); EXPECT_FALSE(load_called_); EXPECT_FALSE(install_called_); } // Try calling install at various bad times -TEST_F(ZoneUpdaterLocalTest, invalidInstall) { +TEST_F(ZoneReloaderLocalTest, invalidInstall) { // Nothing loaded yet - EXPECT_THROW(updater_->install(), isc::Unexpected); + EXPECT_THROW(reloader_->install(), isc::Unexpected); EXPECT_FALSE(load_called_); EXPECT_FALSE(install_called_); - EXPECT_NO_THROW(updater_->load()); + EXPECT_NO_THROW(reloader_->load()); load_called_ = false; // This install is OK - EXPECT_NO_THROW(updater_->install()); + EXPECT_NO_THROW(reloader_->install()); install_called_ = false; // But we can't call it second time now - EXPECT_THROW(updater_->install(), isc::Unexpected); + EXPECT_THROW(reloader_->install(), isc::Unexpected); EXPECT_FALSE(load_called_); EXPECT_FALSE(install_called_); } @@ -190,47 +191,47 @@ TEST_F(ZoneUpdaterLocalTest, invalidInstall) { // We check we can clean without installing first and nothing bad // happens. We also misuse the testcase to check we can't install // after cleanup. -TEST_F(ZoneUpdaterLocalTest, cleanWithoutInstall) { - EXPECT_NO_THROW(updater_->load()); - EXPECT_NO_THROW(updater_->cleanup()); +TEST_F(ZoneReloaderLocalTest, cleanWithoutInstall) { + EXPECT_NO_THROW(reloader_->load()); + EXPECT_NO_THROW(reloader_->cleanup()); EXPECT_TRUE(load_called_); EXPECT_FALSE(install_called_); // We cleaned up, no way to install now - EXPECT_THROW(updater_->install(), isc::Unexpected); + EXPECT_THROW(reloader_->install(), isc::Unexpected); EXPECT_FALSE(install_called_); } // Test the case when load callback throws -TEST_F(ZoneUpdaterLocalTest, loadThrows) { +TEST_F(ZoneReloaderLocalTest, loadThrows) { load_throw_ = true; - EXPECT_THROW(updater_->load(), TestException); + EXPECT_THROW(reloader_->load(), TestException); // We can't install now - EXPECT_THROW(updater_->install(), isc::Unexpected); + EXPECT_THROW(reloader_->install(), isc::Unexpected); EXPECT_TRUE(load_called_); EXPECT_FALSE(install_called_); // But we can cleanup - EXPECT_NO_THROW(updater_->cleanup()); + EXPECT_NO_THROW(reloader_->cleanup()); } // Test we free all our memory even when we throw from install -TEST_F(ZoneUpdaterLocalTest, installThrows) { +TEST_F(ZoneReloaderLocalTest, installThrows) { install_throw_ = true; - EXPECT_NO_THROW(updater_->load()); + EXPECT_NO_THROW(reloader_->load()); - EXPECT_THROW(updater_->install(), TestException); + EXPECT_THROW(reloader_->install(), TestException); EXPECT_TRUE(load_called_); EXPECT_TRUE(install_called_); // We can't try again install_throw_ = false; - EXPECT_THROW(updater_->install(), isc::Unexpected); + EXPECT_THROW(reloader_->install(), isc::Unexpected); // But it is not completely broken - EXPECT_NO_THROW(updater_->cleanup()); + EXPECT_NO_THROW(reloader_->cleanup()); } }