BIND 10 trac2850_2, updated. bc3d482930fad8d97305f07e116093ace8110e9c [2850] Add isUsable() and getImplType() methods
BIND 10 source code commits
bind10-changes at lists.isc.org
Thu May 9 13:23:23 UTC 2013
The branch, trac2850_2 has been updated
via bc3d482930fad8d97305f07e116093ace8110e9c (commit)
from 32d750c6674613bd630eb1e724adc82b8ec8a622 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit bc3d482930fad8d97305f07e116093ace8110e9c
Author: Mukund Sivaraman <muks at isc.org>
Date: Thu May 9 18:40:37 2013 +0530
[2850] Add isUsable() and getImplType() methods
It would be better if these were static (to save on space and also to
use them inside ZoneTableSegment::create()), but unfortunately we cannot
make it virtual then. Another option would be to pass a static string
from ZoneTableSegment::create() onto the ZoneTableSegment constructor
and make it a non-virtual base class method.
-----------------------------------------------------------------------
Summary of changes:
src/lib/datasrc/memory/zone_table_segment.h | 13 +++++-
src/lib/datasrc/memory/zone_table_segment_local.cc | 6 +++
src/lib/datasrc/memory/zone_table_segment_local.h | 14 ++++++
.../datasrc/memory/zone_table_segment_mapped.cc | 20 +++++++--
src/lib/datasrc/memory/zone_table_segment_mapped.h | 10 +++++
.../memory/zone_table_segment_mapped_unittest.cc | 46 +++++++++++++++++---
.../datasrc/tests/memory/zone_table_segment_mock.h | 12 +++++
.../tests/memory/zone_table_segment_unittest.cc | 8 ++++
.../datasrc/tests/memory/zone_writer_unittest.cc | 7 +++
9 files changed, 124 insertions(+), 12 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/datasrc/memory/zone_table_segment.h b/src/lib/datasrc/memory/zone_table_segment.h
index 22c681c..4b6b2c6 100644
--- a/src/lib/datasrc/memory/zone_table_segment.h
+++ b/src/lib/datasrc/memory/zone_table_segment.h
@@ -68,7 +68,7 @@ public:
class ResetFailedAndSegmentCleared : public isc::Exception {
public:
ResetFailedAndSegmentCleared(const char* file, size_t line,
- const char* what) :
+ const char* what) :
isc::Exception(file, line, what)
{}
};
@@ -119,6 +119,10 @@ public:
/// \brief Destructor
virtual ~ZoneTableSegment() {}
+ /// \brief Return a string name for the ZoneTableSegment
+ /// implementation.
+ virtual const std::string& getImplType() const = 0;
+
/// \brief Return the ZoneTableHeader for the zone table segment.
///
/// \throw isc::InvalidOperation may be thrown by some
@@ -263,6 +267,13 @@ public:
/// \throw none
virtual void clear() = 0;
+ /// \brief Return true if the memory segment has been successfully
+ /// \c reset().
+ ///
+ /// Note that after calling \c clear(), this method will return
+ /// false until the segment is reset again.
+ virtual bool isUsable() const = 0;
+
/// \brief Reset the table header address.
virtual void resetHeader() = 0;
};
diff --git a/src/lib/datasrc/memory/zone_table_segment_local.cc b/src/lib/datasrc/memory/zone_table_segment_local.cc
index 5637b97..6a3247b 100644
--- a/src/lib/datasrc/memory/zone_table_segment_local.cc
+++ b/src/lib/datasrc/memory/zone_table_segment_local.cc
@@ -23,6 +23,7 @@ namespace memory {
ZoneTableSegmentLocal::ZoneTableSegmentLocal(const RRClass& rrclass) :
ZoneTableSegment(rrclass),
+ impl_type_("local"),
header_(ZoneTable::create(mem_sgmt_, rrclass))
{
}
@@ -37,6 +38,11 @@ ZoneTableSegmentLocal::~ZoneTableSegmentLocal() {
assert(mem_sgmt_.allMemoryDeallocated());
}
+const std::string&
+ZoneTableSegmentLocal::getImplType() const {
+ return (impl_type_);
+}
+
void
ZoneTableSegmentLocal::reset(MemorySegmentOpenMode,
isc::data::ConstElementPtr)
diff --git a/src/lib/datasrc/memory/zone_table_segment_local.h b/src/lib/datasrc/memory/zone_table_segment_local.h
index e18faa1..c6cb2f1 100644
--- a/src/lib/datasrc/memory/zone_table_segment_local.h
+++ b/src/lib/datasrc/memory/zone_table_segment_local.h
@@ -18,6 +18,8 @@
#include <datasrc/memory/zone_table_segment.h>
#include <util/memory_segment_local.h>
+#include <string>
+
namespace isc {
namespace datasrc {
namespace memory {
@@ -42,6 +44,9 @@ public:
/// \brief Destructor
virtual ~ZoneTableSegmentLocal();
+ /// \brief Returns "local" as the implementation type.
+ virtual const std::string& getImplType() const;
+
/// \brief This method has an empty definition.
virtual void resetHeader();
@@ -75,7 +80,16 @@ public:
/// \throw isc::NotImplemented
virtual void clear();
+ /// \brief Return true if the segment is usable.
+ ///
+ /// Local segments are always usable. This implementation always
+ /// returns true.
+ virtual bool isUsable() const {
+ return (true);
+ }
+
private:
+ std::string impl_type_;
isc::util::MemorySegmentLocal mem_sgmt_;
ZoneTableHeader header_;
};
diff --git a/src/lib/datasrc/memory/zone_table_segment_mapped.cc b/src/lib/datasrc/memory/zone_table_segment_mapped.cc
index db692e0..bd40db4 100644
--- a/src/lib/datasrc/memory/zone_table_segment_mapped.cc
+++ b/src/lib/datasrc/memory/zone_table_segment_mapped.cc
@@ -36,6 +36,7 @@ const char* const ZONE_TABLE_HEADER_NAME = "zone_table_header";
ZoneTableSegmentMapped::ZoneTableSegmentMapped(const RRClass& rrclass) :
ZoneTableSegment(rrclass),
+ impl_type_("mapped"),
rrclass_(rrclass),
cached_header_(NULL)
{
@@ -45,6 +46,11 @@ ZoneTableSegmentMapped::~ZoneTableSegmentMapped() {
sync();
}
+const std::string&
+ZoneTableSegmentMapped::getImplType() const {
+ return (impl_type_);
+}
+
bool
ZoneTableSegmentMapped::processChecksum(MemorySegmentMapped& segment,
bool create,
@@ -325,7 +331,7 @@ ZoneTableSegmentMapped::resetHeader() {
// getHeader() has to work on const objects too. So we do it here
// now.
- if (!mem_sgmt_) {
+ if (!isUsable()) {
isc_throw(isc::InvalidOperation,
"resetHeader() called without calling reset() first");
}
@@ -344,7 +350,7 @@ ZoneTableSegmentMapped::resetHeader() {
template<typename T>
T*
ZoneTableSegmentMapped::getHeaderHelper() const {
- if (!mem_sgmt_) {
+ if (!isUsable()) {
isc_throw(isc::InvalidOperation,
"getHeader() called without calling reset() first");
}
@@ -365,7 +371,7 @@ ZoneTableSegmentMapped::getHeader() const {
MemorySegment&
ZoneTableSegmentMapped::getMemorySegment() {
- if (!mem_sgmt_) {
+ if (!isUsable()) {
isc_throw(isc::InvalidOperation,
"getMemorySegment() called without calling reset() first");
}
@@ -373,8 +379,14 @@ ZoneTableSegmentMapped::getMemorySegment() {
}
bool
+ZoneTableSegmentMapped::isUsable() const {
+ // If mem_sgmt_ is not empty, then it is usable.
+ return (mem_sgmt_);
+}
+
+bool
ZoneTableSegmentMapped::isWritable() const {
- if (!mem_sgmt_) {
+ if (!isUsable()) {
// If reset() was never performed for this segment, or if the
// most recent reset() had failed, then the segment is not
// writable.
diff --git a/src/lib/datasrc/memory/zone_table_segment_mapped.h b/src/lib/datasrc/memory/zone_table_segment_mapped.h
index 63acc2f..3d7f218 100644
--- a/src/lib/datasrc/memory/zone_table_segment_mapped.h
+++ b/src/lib/datasrc/memory/zone_table_segment_mapped.h
@@ -19,6 +19,7 @@
#include <util/memory_segment_mapped.h>
#include <boost/scoped_ptr.hpp>
+#include <string>
namespace isc {
namespace datasrc {
@@ -46,6 +47,9 @@ public:
/// \brief Destructor
virtual ~ZoneTableSegmentMapped();
+ /// \brief Returns "mapped" as the implementation type.
+ virtual const std::string& getImplType() const;
+
/// \brief Reset the table header address from the named address in
/// the mapped file.
virtual void resetHeader();
@@ -111,6 +115,11 @@ public:
/// \brief Unmap the current file (if mapped).
virtual void clear();
+ /// \brief Return true if the segment is usable.
+ ///
+ /// See the base class for the description.
+ virtual bool isUsable() const;
+
private:
void sync();
@@ -126,6 +135,7 @@ private:
template<typename T> T* getHeaderHelper() const;
private:
+ std::string impl_type_;
isc::dns::RRClass rrclass_;
MemorySegmentOpenMode current_mode_;
std::string current_filename_;
diff --git a/src/lib/datasrc/tests/memory/zone_table_segment_mapped_unittest.cc b/src/lib/datasrc/tests/memory/zone_table_segment_mapped_unittest.cc
index 8a6fcaf..441f433 100644
--- a/src/lib/datasrc/tests/memory/zone_table_segment_mapped_unittest.cc
+++ b/src/lib/datasrc/tests/memory/zone_table_segment_mapped_unittest.cc
@@ -172,6 +172,10 @@ ZoneTableSegmentMappedTest::setupMappedFiles() {
ztable_segment_->clear();
}
+TEST_F(ZoneTableSegmentMappedTest, getImplType) {
+ EXPECT_EQ("mapped", ztable_segment_->getImplType());
+}
+
TEST_F(ZoneTableSegmentMappedTest, getHeaderUninitialized) {
// This should throw as we haven't called reset() yet.
EXPECT_THROW(ztable_segment_->getHeader(), isc::InvalidOperation);
@@ -182,6 +186,12 @@ TEST_F(ZoneTableSegmentMappedTest, getMemorySegmentUninitialized) {
EXPECT_THROW(ztable_segment_->getMemorySegment(), isc::InvalidOperation);
}
+TEST_F(ZoneTableSegmentMappedTest, isUsableUninitialized) {
+ // isUsable() must return false by default, when the segment has not
+ // been reset() yet.
+ EXPECT_FALSE(ztable_segment_->isUsable());
+}
+
TEST_F(ZoneTableSegmentMappedTest, isWritableUninitialized) {
// isWritable() must return false by default, when the segment has
// not been reset() yet.
@@ -252,13 +262,15 @@ TEST_F(ZoneTableSegmentMappedTest, reset) {
EXPECT_THROW(ztable_segment_->getHeader(), isc::InvalidOperation);
EXPECT_THROW(ztable_segment_->getMemorySegment(), isc::InvalidOperation);
- // isWritable() must still return false, because the segment has not
- // been successfully reset() yet.
+ // isUsable() and isWritable() must still return false, because the
+ // segment has not been successfully reset() yet.
+ EXPECT_FALSE(ztable_segment_->isUsable());
EXPECT_FALSE(ztable_segment_->isWritable());
// READ_WRITE mode must create the mapped file if it doesn't exist
// (and must not result in an exception).
ztable_segment_->reset(ZoneTableSegment::READ_WRITE, config_params_);
+ EXPECT_TRUE(ztable_segment_->isUsable());
EXPECT_TRUE(ztable_segment_->isWritable());
// The following method calls should no longer throw:
@@ -268,12 +280,14 @@ TEST_F(ZoneTableSegmentMappedTest, reset) {
// Let's try to re-open the mapped file in READ_ONLY mode. It should
// not fail now.
ztable_segment_->reset(ZoneTableSegment::READ_ONLY, config_params_);
+ EXPECT_TRUE(ztable_segment_->isUsable());
EXPECT_FALSE(ztable_segment_->isWritable());
// Re-creating the mapped file should erase old data and should not
// trigger any exceptions inside reset() due to old data (such as
// named addresses).
ztable_segment_->reset(ZoneTableSegment::CREATE, config_params_);
+ EXPECT_TRUE(ztable_segment_->isUsable());
EXPECT_TRUE(ztable_segment_->isWritable());
// When we reset() with an invalid paramter and it fails, then the
@@ -282,6 +296,7 @@ TEST_F(ZoneTableSegmentMappedTest, reset) {
ztable_segment_->reset(ZoneTableSegment::CREATE,
Element::fromJSON("{}"));
}, isc::InvalidParameter);
+ EXPECT_TRUE(ztable_segment_->isUsable());
EXPECT_TRUE(ztable_segment_->isWritable());
// The following should not throw.
EXPECT_NO_THROW(ztable_segment_->getHeader());
@@ -291,6 +306,7 @@ TEST_F(ZoneTableSegmentMappedTest, reset) {
// would use existing named addresses. This actually re-opens the
// currently open map.
ztable_segment_->reset(ZoneTableSegment::READ_WRITE, config_params_);
+ EXPECT_TRUE(ztable_segment_->isUsable());
EXPECT_TRUE(ztable_segment_->isWritable());
}
@@ -301,6 +317,7 @@ TEST_F(ZoneTableSegmentMappedTest, resetCreate) {
// Open the underlying mapped file in create mode.
ztable_segment_->reset(ZoneTableSegment::CREATE, config_params_);
+ ASSERT_TRUE(ztable_segment_->isUsable());
ASSERT_TRUE(ztable_segment_->isWritable());
// Add the data.
@@ -327,6 +344,7 @@ TEST_F(ZoneTableSegmentMappedTest, resetReadWrite) {
// Open the underlying mapped file in read+write mode.
ztable_segment_->reset(ZoneTableSegment::READ_WRITE, config_params_);
+ ASSERT_TRUE(ztable_segment_->isUsable());
ASSERT_TRUE(ztable_segment_->isWritable());
// Add the data.
@@ -353,6 +371,7 @@ TEST_F(ZoneTableSegmentMappedTest, resetReadOnly) {
// Open the underlying mapped file in read+write mode.
ztable_segment_->reset(ZoneTableSegment::READ_WRITE, config_params_);
+ ASSERT_TRUE(ztable_segment_->isUsable());
ASSERT_TRUE(ztable_segment_->isWritable());
// Add the data.
@@ -389,6 +408,7 @@ TEST_F(ZoneTableSegmentMappedTest, clearUninitialized) {
// isWritable() must still return false, because the segment has not
// been successfully reset() yet.
+ EXPECT_FALSE(ztable_segment_->isUsable());
EXPECT_FALSE(ztable_segment_->isWritable());
}
@@ -397,6 +417,7 @@ TEST_F(ZoneTableSegmentMappedTest, clear) {
// exist yet)
ztable_segment_->reset(ZoneTableSegment::READ_WRITE, config_params_);
+ EXPECT_TRUE(ztable_segment_->isUsable());
EXPECT_TRUE(ztable_segment_->isWritable());
// The following method calls should no longer throw:
EXPECT_NO_THROW(ztable_segment_->getHeader());
@@ -405,6 +426,7 @@ TEST_F(ZoneTableSegmentMappedTest, clear) {
// Now, clear the segment.
ztable_segment_->clear();
+ EXPECT_FALSE(ztable_segment_->isUsable());
EXPECT_FALSE(ztable_segment_->isWritable());
// The following method calls should now throw.
EXPECT_THROW(ztable_segment_->getHeader(), isc::InvalidOperation);
@@ -425,11 +447,13 @@ TEST_F(ZoneTableSegmentMappedTest, resetFailedCorruptedChecksum) {
corruptChecksum(*segment);
segment.reset();
- // Opening mapped file 2 in read-write mode should fail
+ // Resetting to mapped file 2 in read-write mode should fail
EXPECT_THROW({
ztable_segment_->reset(ZoneTableSegment::READ_WRITE, config_params2_);
}, ResetFailed);
+ EXPECT_TRUE(ztable_segment_->isUsable());
+ EXPECT_TRUE(ztable_segment_->isWritable());
// Check for the old data in the segment to make sure it is still
// available and correct.
EXPECT_TRUE(verifyData(ztable_segment_->getMemorySegment()));
@@ -449,11 +473,13 @@ TEST_F(ZoneTableSegmentMappedTest, resetFailedMissingChecksum) {
deleteChecksum(*segment);
segment.reset();
- // Opening mapped file 2 in read-only mode should fail
+ // Resetting to mapped file 2 in read-only mode should fail
EXPECT_THROW({
ztable_segment_->reset(ZoneTableSegment::READ_ONLY, config_params2_);
}, ResetFailed);
+ EXPECT_TRUE(ztable_segment_->isUsable());
+ EXPECT_TRUE(ztable_segment_->isWritable());
// Check for the old data in the segment to make sure it is still
// available and correct.
EXPECT_TRUE(verifyData(ztable_segment_->getMemorySegment()));
@@ -473,11 +499,13 @@ TEST_F(ZoneTableSegmentMappedTest, resetFailedMissingHeader) {
deleteHeader(*segment);
segment.reset();
- // Opening mapped file 2 in read-only mode should fail
+ // Resetting to mapped file 2 in read-only mode should fail
EXPECT_THROW({
ztable_segment_->reset(ZoneTableSegment::READ_ONLY, config_params2_);
}, ResetFailed);
+ EXPECT_TRUE(ztable_segment_->isUsable());
+ EXPECT_TRUE(ztable_segment_->isWritable());
// Check for the old data in the segment to make sure it is still
// available and correct.
EXPECT_TRUE(verifyData(ztable_segment_->getMemorySegment()));
@@ -494,11 +522,13 @@ TEST_F(ZoneTableSegmentMappedTest, resetCreateOverCorruptedFile) {
corruptChecksum(*segment);
segment.reset();
- // Resetting mapped file 1 in CREATE mode over a corrupted file
+ // Resetting to mapped file 1 in CREATE mode over a corrupted file
// should pass.
EXPECT_NO_THROW(ztable_segment_->reset(ZoneTableSegment::CREATE,
config_params_));
+ EXPECT_TRUE(ztable_segment_->isUsable());
+ EXPECT_TRUE(ztable_segment_->isWritable());
// Check for the old data in the segment. It should not be present
// (as we opened the segment in CREATE mode).
EXPECT_FALSE(verifyData(ztable_segment_->getMemorySegment()));
@@ -513,11 +543,13 @@ TEST_F(ZoneTableSegmentMappedTest, resetCreateOverCorruptedFile) {
deleteChecksum(*segment);
segment.reset();
- // Resetting mapped file 1 in CREATE mode over a file missing
+ // Resetting to mapped file 1 in CREATE mode over a file missing
// checksum should pass.
EXPECT_NO_THROW(ztable_segment_->reset(ZoneTableSegment::CREATE,
config_params_));
+ EXPECT_TRUE(ztable_segment_->isUsable());
+ EXPECT_TRUE(ztable_segment_->isWritable());
// Check for the old data in the segment. It should not be present
// (as we opened the segment in CREATE mode).
EXPECT_FALSE(verifyData(ztable_segment_->getMemorySegment()));
diff --git a/src/lib/datasrc/tests/memory/zone_table_segment_mock.h b/src/lib/datasrc/tests/memory/zone_table_segment_mock.h
index 4eae191..bd10c1e 100644
--- a/src/lib/datasrc/tests/memory/zone_table_segment_mock.h
+++ b/src/lib/datasrc/tests/memory/zone_table_segment_mock.h
@@ -20,6 +20,8 @@
#include <datasrc/memory/zone_data.h>
#include <datasrc/memory/zone_writer.h>
+#include <string>
+
namespace isc {
namespace datasrc {
namespace memory {
@@ -33,6 +35,7 @@ public:
ZoneTableSegmentMock(const isc::dns::RRClass& rrclass,
isc::util::MemorySegment& mem_sgmt) :
ZoneTableSegment(rrclass),
+ impl_type_("mock"),
mem_sgmt_(mem_sgmt),
header_(ZoneTable::create(mem_sgmt_, rrclass))
{}
@@ -41,6 +44,10 @@ public:
ZoneTable::destroy(mem_sgmt_, header_.getTable());
}
+ const std::string& getImplType() const {
+ return (impl_type_);
+ }
+
virtual void reset(MemorySegmentOpenMode, isc::data::ConstElementPtr) {
isc_throw(isc::NotImplemented, "reset() is not implemented");
}
@@ -66,11 +73,16 @@ public:
return (mem_sgmt_);
}
+ virtual bool isUsable() const {
+ return (true);
+ }
+
virtual bool isWritable() const {
return (true);
}
private:
+ std::string impl_type_;
isc::util::MemorySegment& mem_sgmt_;
ZoneTableHeader header_;
};
diff --git a/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc b/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc
index 97a3fb5..f0a07da 100644
--- a/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc
+++ b/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc
@@ -41,6 +41,9 @@ protected:
ZoneTableSegment* ztable_segment_;
};
+TEST_F(ZoneTableSegmentTest, getImplType) {
+ EXPECT_EQ("local", ztable_segment_->getImplType());
+}
TEST_F(ZoneTableSegmentTest, create) {
// By default, a local zone table segment is created.
@@ -106,6 +109,11 @@ TEST_F(ZoneTableSegmentTest, getMemorySegment) {
mem_sgmt.allMemoryDeallocated(); // use mem_sgmt
}
+TEST_F(ZoneTableSegmentTest, isUsable) {
+ // Local segments are always usable.
+ EXPECT_TRUE(ztable_segment_->isUsable());
+}
+
TEST_F(ZoneTableSegmentTest, isWritable) {
// Local segments are always writable.
EXPECT_TRUE(ztable_segment_->isWritable());
diff --git a/src/lib/datasrc/tests/memory/zone_writer_unittest.cc b/src/lib/datasrc/tests/memory/zone_writer_unittest.cc
index 455e1c9..23e8e20 100644
--- a/src/lib/datasrc/tests/memory/zone_writer_unittest.cc
+++ b/src/lib/datasrc/tests/memory/zone_writer_unittest.cc
@@ -95,6 +95,13 @@ public:
ZoneTableSegmentMock(rrclass, mem_sgmt)
{}
+ // Returns false indicating that the segment is not usable. We
+ // override this too as ZoneTableSegment implementations may use it
+ // internally.
+ virtual bool isUsable() const {
+ return (false);
+ }
+
// Returns false indicating it is a read-only segment. It is used in
// the ZoneWriter tests.
virtual bool isWritable() const {
More information about the bind10-changes
mailing list