BIND 10 master, updated. b477df5d4dbce5b72ebd183b83555f62aa3fcec5 Merge branch 'master' of git+ssh://bind10.isc.org/var/bind10/git/bind10
BIND 10 source code commits
bind10-changes at lists.isc.org
Mon Jun 27 10:56:52 UTC 2011
The branch, master has been updated
via b477df5d4dbce5b72ebd183b83555f62aa3fcec5 (commit)
via 5d5173ef0cc48d206464b39f696d03bae9daecea (commit)
via 7cc074aacd5159778111fa4cbdbe1c89e6a4e51b (commit)
via 0f1b7a45520517a40b7b85d57d461e20e81b7aa9 (commit)
via 885a4ecf9c87b8e3a028b6488b0e6b853365edc8 (commit)
via 77367a5d67709b65afd8689159e5192416326cb7 (commit)
via 55689c559b3ac60765940d64a5b51007f94bddf7 (commit)
via 3f47015eab1abd9c7193a9e740f794c6a718c9f7 (commit)
via 4064b389d13d2861083499517f51d89492156099 (commit)
via 1ab0f2e8448a20674bfb8d12d463e5b3fec3ac6e (commit)
via 81b49bb4d72fdfb5db8d7ad5f9b086c489acdb86 (commit)
via eeebde9d81c4bbc4e5388db5cd6148ca3589b91e (commit)
via 8c5e6268927737a472348d1ff8ecb2201c76b98a (commit)
via cda19a7cbc56ddd67c7d19ec7d072a64477d254b (commit)
via c65177c8ea0dfba3aaa84ea1bf2583b2d818d23d (commit)
from dc087934c1a1946cfdcf63b49a70aa0fefe6b282 (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 b477df5d4dbce5b72ebd183b83555f62aa3fcec5
Merge: 5d5173ef0cc48d206464b39f696d03bae9daecea dc087934c1a1946cfdcf63b49a70aa0fefe6b282
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 27 12:52:56 2011 +0200
Merge branch 'master' of git+ssh://bind10.isc.org/var/bind10/git/bind10
commit 5d5173ef0cc48d206464b39f696d03bae9daecea
Merge: 7cc074aacd5159778111fa4cbdbe1c89e6a4e51b 55689c559b3ac60765940d64a5b51007f94bddf7
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 27 12:47:39 2011 +0200
Merge branch 'work/abbreviated'
commit 7cc074aacd5159778111fa4cbdbe1c89e6a4e51b
Merge: feed2b3537a4e57e4cb55232242c6622d1fcc654 0f1b7a45520517a40b7b85d57d461e20e81b7aa9
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 27 12:47:30 2011 +0200
Merge branch 'work/logic'
Conflicts:
src/lib/acl/Makefile.am
src/lib/acl/tests/Makefile.am
commit 0f1b7a45520517a40b7b85d57d461e20e81b7aa9
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Fri Jun 24 23:29:14 2011 +0200
[trac979] Few more tests
commit 885a4ecf9c87b8e3a028b6488b0e6b853365edc8
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Fri Jun 24 23:16:42 2011 +0200
[trac979] Simplification of expression
commit 77367a5d67709b65afd8689159e5192416326cb7
Author: Stephen Morris <stephen at isc.org>
Date: Fri Jun 24 18:31:58 2011 +0100
[trac979] Add missing libraries to tests/Makefile.am
commit 55689c559b3ac60765940d64a5b51007f94bddf7
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Tue Jun 21 14:16:56 2011 +0200
[trac980] Both abbreviated forms at once tested
commit 3f47015eab1abd9c7193a9e740f794c6a718c9f7
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Tue Jun 21 13:53:46 2011 +0200
[trac980] AND-abbreviated form
commit 4064b389d13d2861083499517f51d89492156099
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Tue Jun 21 13:36:02 2011 +0200
[trac980] OR-abbreviated form
commit 1ab0f2e8448a20674bfb8d12d463e5b3fec3ac6e
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Tue Jun 21 11:54:44 2011 +0200
[trac980] Tests for abbreviated forms
commit 81b49bb4d72fdfb5db8d7ad5f9b086c489acdb86
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 20 16:24:47 2011 +0200
[trac979] Implement the creator and its tests
It takes some test utilities from inside the loader tests and places
them to a header, to be shared by this test as well.
This includes small fix of loader interface, some of its methods can
(and should) be const.
commit eeebde9d81c4bbc4e5388db5cd6148ca3589b91e
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 20 14:50:37 2011 +0200
[trac979] Documentation comments
commit 8c5e6268927737a472348d1ff8ecb2201c76b98a
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 20 14:29:12 2011 +0200
[trac979] Implementation of the logic checks
commit cda19a7cbc56ddd67c7d19ec7d072a64477d254b
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 20 14:10:24 2011 +0200
[trac979] Tests for the checks
commit c65177c8ea0dfba3aaa84ea1bf2583b2d818d23d
Author: Michal 'vorner' Vaner <michal.vaner at nic.cz>
Date: Mon Jun 20 13:52:41 2011 +0200
[trac979] First shot at the interface
-----------------------------------------------------------------------
Summary of changes:
src/lib/acl/Makefile.am | 1 +
src/lib/acl/loader.h | 64 +++++++++--
src/lib/acl/logic_check.h | 206 ++++++++++++++++++++++++++++++++
src/lib/acl/tests/Makefile.am | 1 +
src/lib/acl/tests/creators.h | 154 ++++++++++++++++++++++++
src/lib/acl/tests/loader_test.cc | 209 ++++++++++++---------------------
src/lib/acl/tests/logcheck.h | 5 +
src/lib/acl/tests/logic_check_test.cc | 208 ++++++++++++++++++++++++++++++++
8 files changed, 706 insertions(+), 142 deletions(-)
create mode 100644 src/lib/acl/logic_check.h
create mode 100644 src/lib/acl/tests/creators.h
create mode 100644 src/lib/acl/tests/logic_check_test.cc
-----------------------------------------------------------------------
diff --git a/src/lib/acl/Makefile.am b/src/lib/acl/Makefile.am
index a5ce86f..defaf13 100644
--- a/src/lib/acl/Makefile.am
+++ b/src/lib/acl/Makefile.am
@@ -10,6 +10,7 @@ lib_LTLIBRARIES = libacl.la
libacl_la_SOURCES = acl.h
libacl_la_SOURCES += check.h
libacl_la_SOURCES += ip_check.h ip_check.cc
+libacl_la_SOURCES += logic_check.h
libacl_la_SOURCES += loader.h loader.cc
libacl_la_LIBADD = $(top_builddir)/src/lib/exceptions/libexceptions.la
diff --git a/src/lib/acl/loader.h b/src/lib/acl/loader.h
index 11e7ebc..c3400cb 100644
--- a/src/lib/acl/loader.h
+++ b/src/lib/acl/loader.h
@@ -24,6 +24,10 @@
namespace isc {
namespace acl {
+class AnyOfSpec;
+class AllOfSpec;
+template<typename Mode, typename Context> class LogicOperator;
+
/**
* \brief Exception for bad ACL specifications.
*
@@ -263,7 +267,7 @@ public:
* \param description The JSON description of the check.
*/
boost::shared_ptr<Check<Context> > loadCheck(const data::ConstElementPtr&
- description)
+ description) const
{
// Get the description as a map
typedef std::map<std::string, data::ConstElementPtr> Map;
@@ -290,7 +294,7 @@ public:
* \param description The JSON list of ACL.
*/
boost::shared_ptr<ACL<Context, Action> > load(const data::ConstElementPtr&
- description)
+ description) const
{
// We first check it's a list, so we can use the list reference
// (the list may be huge)
@@ -346,7 +350,7 @@ private:
* the map.
*/
boost::shared_ptr<Check<Context> > loadCheck(const data::ConstElementPtr&
- description, Map& map)
+ description, Map& map) const
{
// Remove the action keyword
map.erase("action");
@@ -367,18 +371,45 @@ private:
}
if (creatorIt->second->allowListAbbreviation() &&
checkDesc->second->getType() == data::Element::list) {
- isc_throw_1(LoaderError,
- "Not implemented (OR-abbreviated form)",
- checkDesc->second);
+ // Or-abbreviated form - create an OR and put everything
+ // inside.
+ const std::vector<data::ConstElementPtr>&
+ params(checkDesc->second->listValue());
+ boost::shared_ptr<LogicOperator<AnyOfSpec, Context> >
+ oper(new LogicOperator<AnyOfSpec, Context>);
+ for (std::vector<data::ConstElementPtr>::const_iterator
+ i(params.begin());
+ i != params.end(); ++i) {
+ oper->addSubexpression(
+ creatorIt->second->create(name, *i, *this));
+ }
+ return (oper);
}
// Create the check and return it
return (creatorIt->second->create(name, checkDesc->second,
*this));
}
- default:
- isc_throw_1(LoaderError,
- "Not implemented (AND-abbreviated form)",
- description);
+ default: {
+ // This is the AND-abbreviated form. We need to create an
+ // AND (or "ALL") operator, loop trough the whole map and
+ // fill it in. We do a small trick - we create bunch of
+ // single-item maps, call this loader recursively (therefore
+ // it will get into the "case 1" branch, where there is
+ // the actual loading) and use the results to fill the map.
+ //
+ // We keep the description the same, there's nothing we could
+ // take out (we could create a new one, but that would be
+ // confusing, as it is used for error messages only).
+ boost::shared_ptr<LogicOperator<AllOfSpec, Context> >
+ oper(new LogicOperator<AllOfSpec, Context>);
+ for (Map::const_iterator i(map.begin()); i != map.end(); ++i) {
+ Map singleSubexpr;
+ singleSubexpr.insert(*i);
+ oper->addSubexpression(loadCheck(description,
+ singleSubexpr));
+ }
+ return (oper);
+ }
}
}
/**
@@ -401,4 +432,17 @@ private:
}
}
+/*
+ * This include at the end of the file is unusual. But we need to include it,
+ * we use template classes from there. However, they need to be present only
+ * at instantiation of our class, which will happen below this header.
+ *
+ * The problem is, the header uses us as well, therefore there's a circular
+ * dependency. If we loaded it at the beginning and someone loaded us first,
+ * the logic_check header wouldn't have our definitions. This way, no matter
+ * in which order they are loaded, the definitions from this header will be
+ * above the ones from logic_check.
+ */
+#include "logic_check.h"
+
#endif
diff --git a/src/lib/acl/logic_check.h b/src/lib/acl/logic_check.h
new file mode 100644
index 0000000..6e1c567
--- /dev/null
+++ b/src/lib/acl/logic_check.h
@@ -0,0 +1,206 @@
+// Copyright (C) 2011 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef ACL_LOGIC_CHECK_H
+#define ACL_LOGIC_CHECK_H
+
+#include "check.h"
+#include "loader.h"
+
+namespace isc {
+namespace acl {
+
+/// \brief Constants for the AnyOf implementation
+class AnyOfSpec {
+public:
+ static bool start() { return (false); }
+ static bool terminate(const bool another) {
+ return (another);
+ }
+};
+
+/// \brief Constants for the AllOf implementation
+class AllOfSpec {
+public:
+ static bool start() { return (true); }
+ static bool terminate(const bool another) {
+ return (!another);
+ }
+};
+
+/**
+ * \brief Logic operators
+ *
+ * This class implements the AllOf and AnyOf compound checks. As their
+ * behaviour is almost the same, the same template class is used. Which
+ * one it is depends on the Mode template parameter. The Mode should be
+ * one of AnyOfSpec or AllOfSpec, which provide some commands for the
+ * internal implementation. It would be nice to provide typedefs for
+ * them, but it is impossible to do so, as we have the Context template
+ * parameter as well and C++ doesn't like templated typedefs.
+ *
+ * The object holds several subexpressions and returns true if all
+ * of the subexpressions return true (in case of AllOfSpec Mode) or
+ * at last one of them return true (in case of AnyOfSpec Mode). If
+ * some subexpression guarantees the result (eg. some returns false
+ * in case of AllOfSpec), the rest is not tried for performance
+ * reasons.
+ */
+template<typename Mode, typename Context>
+class LogicOperator : public CompoundCheck<Context> {
+public:
+ /**
+ * \brief Add another subexpression.
+ *
+ * This adds another subexpression to the list of checked expressions.
+ * This is usually done shortly after the creation, before using the
+ * check for matches.
+ *
+ * Currently there's no way to place the expression into arbitrary place
+ * or to remove it. It might turn out it would be needed in future to
+ * optimise or it might even turn out we need shared pointers for it.
+ *
+ * \param expr The new expression to put inside.
+ */
+ void addSubexpression(const boost::shared_ptr<Check<Context> >& expr) {
+ checks_.push_back(expr);
+ }
+ /**
+ * \brief The current list of subexpressions.
+ */
+ virtual typename CompoundCheck<Context>::Checks getSubexpressions() const {
+ typename CompoundCheck<Context>::Checks result;
+ for (typename Checks::const_iterator i(checks_.begin());
+ i != checks_.end(); ++i) {
+ result.push_back(i->get());
+ }
+ return (result);
+ }
+ /**
+ * \brief The match of the check.
+ *
+ * Runs the subexpressions, one by one, and then decides based on that
+ * what to return.
+ */
+ virtual bool matches(const Context& context) const {
+ /*
+ * This might look slightly complicated. However, this is just
+ * generalized version of multi-and or multi-or. The usual
+ * implementation of multi-and starts with true and if one with
+ * false is found, it turns to be false forever and false is
+ * returned. It is exactly the other way around with or.
+ *
+ * So, if we ever find one that makes it the other one than start
+ * (false in case of and, true in case of or), we can just stop and
+ * return that one right away. If it meets no such expression, we
+ * get to the end and return the default.
+ */
+ for (typename Checks::const_iterator i(checks_.begin());
+ i != checks_.end(); ++i) {
+ if (Mode::terminate((*i)->matches(context))) {
+ return (!Mode::start());
+ }
+ }
+ return (Mode::start());
+ }
+private:
+ /// \brief List of subexpressions
+ typedef typename std::vector<boost::shared_ptr<Check<Context> > > Checks;
+ Checks checks_;
+};
+
+/**
+ * \brief Creator for the LogicOperator compound check.
+ *
+ * This class can load the ANY and ALL operators from JSON. They expect
+ * a list of subexpressions as a parameter, eg. like this:
+ *
+ * \verbatim
+ * {"ANY": [
+ * {"ip": "1.2.3.4"},
+ * {"ip": "5.6.7.8"}
+ * ]}
+ * \endverbatim
+ *
+ * It uses the loader to load the subexpressions, therefore whatever is
+ * supported there is supported here as well.
+ *
+ * The Mode template parameter has the same meaning as with LogicOperator,
+ * it is used to know which operators to create.
+ */
+template<typename Mode, typename Context, typename Action = BasicAction>
+class LogicCreator : public Loader<Context, Action>::CheckCreator {
+public:
+ /**
+ * \brief Constructor.
+ *
+ * \param name The name for which the loader will work. In practice,
+ * it will usually be ANY or ALL (depending on the mode), but
+ * anything else can be used as well.
+ */
+ LogicCreator(const std::string& name) :
+ name_(name)
+ {}
+ /// \brief Returns vector containing the name.
+ virtual std::vector<std::string> names() const {
+ std::vector<std::string> result;
+ result.push_back(name_);
+ return (result);
+ }
+ /**
+ * \brief Converts a JSON description into the logic operator.
+ *
+ * This is the place where the actual loading happens. It creates
+ * the logic operator and calls the loader on each of the list
+ * elements, placing the result into the logic operator.
+ *
+ * The first parameter is ignored and is there only to match interface.
+ *
+ * \param definition The JSON definition of the subexpressions. This must
+ * be a list (if it isn't, the LoaderError is thrown) and the elements
+ * must be loadable by the loader (the exceptions from it are not
+ * caught).
+ * \param loader The loader to use for loading of subexpressions.
+ */
+ virtual boost::shared_ptr<Check<Context> > create(const std::string&,
+ data::ConstElementPtr
+ definition,
+ const Loader<Context,
+ Action>& loader)
+ {
+ std::vector<data::ConstElementPtr> subexprs;
+ try {
+ subexprs = definition->listValue();
+ }
+ catch (const data::TypeError&) {
+ isc_throw_1(LoaderError, "Logic operator takes list", definition);
+ }
+ boost::shared_ptr<LogicOperator<Mode, Context> >
+ result(new LogicOperator<Mode, Context>);
+ for (std::vector<data::ConstElementPtr>::const_iterator
+ i(subexprs.begin());
+ i != subexprs.end(); ++i) {
+ result->addSubexpression(loader.loadCheck(*i));
+ }
+ return (result);
+ }
+ virtual bool allowListAbbreviation() const { return (false); }
+private:
+ const std::string name_;
+};
+
+}
+}
+
+#endif
diff --git a/src/lib/acl/tests/Makefile.am b/src/lib/acl/tests/Makefile.am
index 0f17e37..ae137a8 100644
--- a/src/lib/acl/tests/Makefile.am
+++ b/src/lib/acl/tests/Makefile.am
@@ -11,6 +11,7 @@ run_unittests_SOURCES += dns_test.cc
run_unittests_SOURCES += ip_check_unittest.cc
run_unittests_SOURCES += loader_test.cc
run_unittests_SOURCES += logcheck.h
+run_unittests_SOURCES += logic_check_test.cc
run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
run_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
diff --git a/src/lib/acl/tests/creators.h b/src/lib/acl/tests/creators.h
new file mode 100644
index 0000000..85f3444
--- /dev/null
+++ b/src/lib/acl/tests/creators.h
@@ -0,0 +1,154 @@
+// Copyright (C) 2011 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+// This is not a public header, but some code shared between tests
+// This one contains various creators to test the loader and other creators
+
+#ifndef CREATORS_H
+#define CREATORS_H
+
+#include "logcheck.h"
+#include <acl/loader.h>
+#include <string>
+
+using isc::data::ConstElementPtr;
+using namespace std;
+using namespace boost;
+
+namespace {
+
+// Just for convenience, create JSON objects from JSON string
+ConstElementPtr el(const string& JSON) {
+ return (isc::data::Element::fromJSON(JSON));
+}
+
+// A check that doesn't check anything but remembers it's own name
+// and data
+class NamedCheck : public Check<Log> {
+public:
+ NamedCheck(const string& name, ConstElementPtr data) :
+ name_(name),
+ data_(data)
+ {}
+ virtual bool matches(const Log&) const { return (true); }
+ const string name_;
+ const ConstElementPtr data_;
+};
+
+// The creator of NamedCheck
+class NamedCreator : public Loader<Log>::CheckCreator {
+public:
+ NamedCreator(const string& name, bool abbreviatedList = true) :
+ abbreviated_list_(abbreviatedList)
+ {
+ names_.push_back(name);
+ }
+ NamedCreator(const vector<string>& names) :
+ names_(names),
+ abbreviated_list_(true)
+ {}
+ vector<string> names() const {
+ return (names_);
+ }
+ shared_ptr<Check<Log> > create(const string& name, ConstElementPtr data,
+ const Loader<Log>&)
+ {
+ bool found(false);
+ for (vector<string>::const_iterator i(names_.begin());
+ i != names_.end(); ++i) {
+ if (*i == name) {
+ found = true;
+ break;
+ }
+ }
+ EXPECT_TRUE(found) << "Name " << name << " passed to creator which "
+ "doesn't handle it.";
+ return (shared_ptr<Check<Log> >(new NamedCheck(name, data)));
+ }
+ bool allowListAbbreviation() const {
+ return (abbreviated_list_);
+ }
+private:
+ vector<string> names_;
+ const bool abbreviated_list_;
+};
+
+// To be thrown in tests internally
+class TestCreatorError {};
+
+// This will throw every time it should create something
+class ThrowCreator : public Loader<Log>::CheckCreator {
+public:
+ vector<string> names() const {
+ vector<string> result;
+ result.push_back("throw");
+ return (result);
+ }
+ shared_ptr<Check<Log> > create(const string&, ConstElementPtr,
+ const Loader<Log>&)
+ {
+ throw TestCreatorError();
+ }
+};
+
+// This throws whenever the match is called on it
+class ThrowCheck : public Check<Log> {
+public:
+ virtual bool matches(const Log&) const {
+ throw TestCreatorError();
+ }
+};
+
+// And creator for it
+class ThrowCheckCreator : public Loader<Log>::CheckCreator {
+public:
+ vector<string> names() const {
+ vector<string> result;
+ result.push_back("throwcheck");
+ return (result);
+ }
+ shared_ptr<Check<Log> > create(const string&, ConstElementPtr,
+ const Loader<Log>&)
+ {
+ return (shared_ptr<Check<Log> >(new ThrowCheck()));
+ }
+};
+
+class LogCreator : public Loader<Log>::CheckCreator {
+public:
+ vector<string> names() const {
+ vector<string> result;
+ result.push_back("logcheck");
+ return (result);
+ }
+ /*
+ * For simplicity, we just take two values as a list, first is the
+ * logging cell used, the second is result of the check. No error checking
+ * is done, if there's bug in the test, it will throw TypeError for us.
+ */
+ shared_ptr<Check<Log> > create(const string&, ConstElementPtr definition,
+ const Loader<Log>&)
+ {
+ vector<ConstElementPtr> list(definition->listValue());
+ int logpos(list[0]->intValue());
+ bool accept(list[1]->boolValue());
+ return (shared_ptr<ConstCheck>(new ConstCheck(accept, logpos)));
+ }
+ // We take a list, so don't interpret it for us
+ virtual bool allowListAbbreviation() const { return (false); }
+};
+
+}
+
+#endif
diff --git a/src/lib/acl/tests/loader_test.cc b/src/lib/acl/tests/loader_test.cc
index 92d40a8..7dc088d 100644
--- a/src/lib/acl/tests/loader_test.cc
+++ b/src/lib/acl/tests/loader_test.cc
@@ -12,22 +12,16 @@
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
-#include "logcheck.h"
+#include "creators.h"
#include <acl/loader.h>
#include <string>
#include <gtest/gtest.h>
using namespace std;
using namespace boost;
-using isc::data::ConstElementPtr;
namespace {
-// Just for convenience, create JSON objects from JSON string
-ConstElementPtr el(const string& JSON) {
- return (isc::data::Element::fromJSON(JSON));
-}
-
// We don't use the EXPECT_THROW macro, as it doesn't allow us
// to examine the exception. We want to check the element is stored
// there as well.
@@ -61,122 +55,6 @@ TEST(LoaderHelpers, DefaultActionLoader) {
testActionLoaderException("{}");
}
-// A check that doesn't check anything but remembers it's own name
-// and data
-class NamedCheck : public Check<Log> {
-public:
- NamedCheck(const string& name, ConstElementPtr data) :
- name_(name),
- data_(data)
- {}
- virtual bool matches(const Log&) const { return (true); }
- const string name_;
- const ConstElementPtr data_;
-};
-
-// The creator of NamedCheck
-class NamedCreator : public Loader<Log>::CheckCreator {
-public:
- NamedCreator(const string& name, bool abbreviatedList = true) :
- abbreviated_list_(abbreviatedList)
- {
- names_.push_back(name);
- }
- NamedCreator(const vector<string>& names) :
- names_(names),
- abbreviated_list_(true)
- {}
- vector<string> names() const {
- return (names_);
- }
- shared_ptr<Check<Log> > create(const string& name, ConstElementPtr data,
- const Loader<Log>&)
- {
- bool found(false);
- for (vector<string>::const_iterator i(names_.begin());
- i != names_.end(); ++i) {
- if (*i == name) {
- found = true;
- break;
- }
- }
- EXPECT_TRUE(found) << "Name " << name << " passed to creator which "
- "doesn't handle it.";
- return (shared_ptr<Check<Log> >(new NamedCheck(name, data)));
- }
- bool allowListAbbreviation() const {
- return (abbreviated_list_);
- }
-private:
- vector<string> names_;
- const bool abbreviated_list_;
-};
-
-// To be thrown in tests internally
-class TestCreatorError {};
-
-// This will throw every time it should create something
-class ThrowCreator : public Loader<Log>::CheckCreator {
-public:
- vector<string> names() const {
- vector<string> result;
- result.push_back("throw");
- return (result);
- }
- shared_ptr<Check<Log> > create(const string&, ConstElementPtr,
- const Loader<Log>&)
- {
- throw TestCreatorError();
- }
-};
-
-// This throws whenever the match is called on it
-class ThrowCheck : public Check<Log> {
-public:
- virtual bool matches(const Log&) const {
- throw TestCreatorError();
- }
-};
-
-// And creator for it
-class ThrowCheckCreator : public Loader<Log>::CheckCreator {
-public:
- vector<string> names() const {
- vector<string> result;
- result.push_back("throwcheck");
- return (result);
- }
- shared_ptr<Check<Log> > create(const string&, ConstElementPtr,
- const Loader<Log>&)
- {
- return (shared_ptr<Check<Log> >(new ThrowCheck()));
- }
-};
-
-class LogCreator : public Loader<Log>::CheckCreator {
-public:
- vector<string> names() const {
- vector<string> result;
- result.push_back("logcheck");
- return (result);
- }
- /*
- * For simplicity, we just take two values as a list, first is the
- * logging cell used, the second is result of the check. No error checking
- * is done, if there's bug in the test, it will throw TypeError for us.
- */
- shared_ptr<Check<Log> > create(const string&, ConstElementPtr definition,
- const Loader<Log>&)
- {
- vector<ConstElementPtr> list(definition->listValue());
- int logpos(list[0]->intValue());
- bool accept(list[1]->boolValue());
- return (shared_ptr<ConstCheck>(new ConstCheck(accept, logpos)));
- }
- // We take a list, so don't interpret it for us
- virtual bool allowListAbbreviation() const { return (false); }
-};
-
class LoaderTest : public ::testing::Test {
public:
LoaderTest() :
@@ -198,16 +76,21 @@ public:
EXPECT_NO_THROW(loader_.registerCreator(
namedCreator(name, abbreviatedList)));
}
- // Load a check and convert it to named check to examine it
- shared_ptr<NamedCheck> loadCheck(const string& definition) {
+ template<class Result> shared_ptr<Result> loadCheckAny(const string&
+ definition)
+ {
SCOPED_TRACE("Loading check " + definition);
shared_ptr<Check<Log> > loaded;
EXPECT_NO_THROW(loaded = loader_.loadCheck(el(definition)));
- shared_ptr<NamedCheck> result(dynamic_pointer_cast<NamedCheck>(
+ shared_ptr<Result> result(dynamic_pointer_cast<Result>(
loaded));
EXPECT_TRUE(result);
return (result);
}
+ // Load a check and convert it to named check to examine it
+ shared_ptr<NamedCheck> loadCheck(const string& definition) {
+ return (loadCheckAny<NamedCheck>(definition));
+ }
// The loadCheck throws an exception
void checkException(const string& JSON) {
SCOPED_TRACE("Loading check exception: " + JSON);
@@ -255,6 +138,20 @@ public:
aclSetup();
EXPECT_THROW(loader_.load(el(JSON)), LoaderError);
}
+ // Check that the subexpression is NamedCheck with correct data
+ void isSubexprNamed(const CompoundCheck<Log>* compound, size_t index,
+ const string& name, ConstElementPtr data)
+ {
+ if (index < compound->getSubexpressions().size()) {
+ const NamedCheck*
+ check(dynamic_cast<const NamedCheck*>(compound->
+ getSubexpressions()
+ [index]));
+ ASSERT_TRUE(check) << "The subexpression is of different type";
+ EXPECT_EQ(name, check->name_);
+ EXPECT_TRUE(data->equals(*check->data_));
+ }
+ }
};
// Test that it does not accept duplicate creator
@@ -331,19 +228,67 @@ TEST_F(LoaderTest, CheckPropagate) {
EXPECT_THROW(loader_.loadCheck(el("{\"throw\": null}")), TestCreatorError);
}
-// The abbreviated form is not yet implemented
-// (we need the operators to be implemented)
+// The abbreviated form of check
TEST_F(LoaderTest, AndAbbrev) {
addNamed("name1");
addNamed("name2");
- EXPECT_THROW(loader_.loadCheck(el("{\"name1\": 1, \"name2\": 2}")),
- LoaderError);
+ shared_ptr<LogicOperator<AllOfSpec, Log> > oper(
+ loadCheckAny<LogicOperator<AllOfSpec, Log> >("{\"name1\": 1, \"name2\": 2}"));
+ // If we don't have anything loaded, the rest would crash. It is already
+ // reported from within loadCheckAny if it isn't loaded.
+ if (oper) {
+ // The subexpressions are correct
+ EXPECT_EQ(2, oper->getSubexpressions().size());
+ // Note: this test relies on the ordering in which map returns it's
+ // elements, which is in the lexicographical order of the strings.
+ // This is not required from our interface, but is easier to write
+ // the test.
+ isSubexprNamed(&*oper, 0, "name1", el("1"));
+ isSubexprNamed(&*oper, 1, "name2", el("2"));
+ }
}
+// The abbreviated form of parameters
TEST_F(LoaderTest, OrAbbrev) {
addNamed("name1");
- EXPECT_THROW(loader_.loadCheck(el("{\"name1\": [1, 2]}")),
- LoaderError);
+ shared_ptr<LogicOperator<AnyOfSpec, Log> > oper(
+ loadCheckAny<LogicOperator<AnyOfSpec, Log> >("{\"name1\": [1, 2]}"));
+ // If we don't have anything loaded, the rest would crash. It is already
+ // reported from within loadCheckAny if it isn't loaded.
+ if (oper) {
+ // The subexpressions are correct
+ EXPECT_EQ(2, oper->getSubexpressions().size());
+ isSubexprNamed(&*oper, 0, "name1", el("1"));
+ isSubexprNamed(&*oper, 1, "name1", el("2"));
+ }
+}
+
+// Combined abbreviated form, both at once
+
+// The abbreviated form of check
+TEST_F(LoaderTest, BothAbbrev) {
+ addNamed("name1");
+ addNamed("name2");
+ shared_ptr<LogicOperator<AllOfSpec, Log> > oper(
+ loadCheckAny<LogicOperator<AllOfSpec, Log> >("{\"name1\": 1, \"name2\": [3, 4]}"));
+ // If we don't have anything loaded, the rest would crash. It is already
+ // reported from within loadCheckAny if it isn't loaded.
+ if (oper) {
+ // The subexpressions are correct
+ ASSERT_EQ(2, oper->getSubexpressions().size());
+ // Note: this test relies on the ordering in which map returns it's
+ // elements, which is in the lexicographical order of the strings.
+ // This is not required from our interface, but is easier to write
+ // the test.
+ isSubexprNamed(&*oper, 0, "name1", el("1"));
+ const LogicOperator<AnyOfSpec, Log>*
+ orOper(dynamic_cast<const LogicOperator<AnyOfSpec, Log>*>(
+ oper->getSubexpressions()[1]));
+ ASSERT_TRUE(orOper) << "Different type than AnyOf operator";
+ EXPECT_EQ(2, orOper->getSubexpressions().size());
+ isSubexprNamed(orOper, 0, "name2", el("3"));
+ isSubexprNamed(orOper, 1, "name2", el("4"));
+ }
}
// But this is not abbreviated form, this should be passed directly to the
diff --git a/src/lib/acl/tests/logcheck.h b/src/lib/acl/tests/logcheck.h
index c5e1bb1..776ff53 100644
--- a/src/lib/acl/tests/logcheck.h
+++ b/src/lib/acl/tests/logcheck.h
@@ -12,6 +12,9 @@
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
+#ifndef LOGCHECK_H
+#define LOGCHECK_H
+
#include <gtest/gtest.h>
#include <acl/acl.h>
#include <cassert>
@@ -84,3 +87,5 @@ private:
};
}
+
+#endif
diff --git a/src/lib/acl/tests/logic_check_test.cc b/src/lib/acl/tests/logic_check_test.cc
new file mode 100644
index 0000000..c4b00eb
--- /dev/null
+++ b/src/lib/acl/tests/logic_check_test.cc
@@ -0,0 +1,208 @@
+// Copyright (C) 2011 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "creators.h"
+#include <acl/logic_check.h>
+
+using namespace isc::acl;
+
+namespace {
+
+// Test the defs in AnyOfSpec
+TEST(LogicOperators, AnyOfSpec) {
+ EXPECT_FALSE(AnyOfSpec::start());
+ EXPECT_FALSE(AnyOfSpec::terminate(false));
+ EXPECT_TRUE(AnyOfSpec::terminate(true));
+}
+
+// Test the defs in AllOfSpec
+TEST(LogicOperators, AllOfSpec) {
+ EXPECT_TRUE(AllOfSpec::start());
+ EXPECT_TRUE(AllOfSpec::terminate(false));
+ EXPECT_FALSE(AllOfSpec::terminate(true));
+}
+
+// Generic test of one check
+template<typename Mode>
+void
+testCheck(bool emptyResult) {
+ // It can be created
+ LogicOperator<Mode, Log> oper;
+ // It is empty by default
+ EXPECT_EQ(0, oper.getSubexpressions().size());
+ // And returns true, as all 0 of the subexpressions return true
+ Log log;
+ EXPECT_EQ(emptyResult, oper.matches(log));
+ log.checkFirst(0);
+ // Fill it with some subexpressions
+ typedef shared_ptr<ConstCheck> CheckPtr;
+ oper.addSubexpression(CheckPtr(new ConstCheck(emptyResult, 0)));
+ oper.addSubexpression(CheckPtr(new ConstCheck(emptyResult, 1)));
+ // Check what happens when only the default-valued are there
+ EXPECT_EQ(2, oper.getSubexpressions().size());
+ EXPECT_EQ(emptyResult, oper.matches(log));
+ log.checkFirst(2);
+ oper.addSubexpression(CheckPtr(new ConstCheck(!emptyResult, 2)));
+ oper.addSubexpression(CheckPtr(new ConstCheck(!emptyResult, 3)));
+ // They are listed there
+ EXPECT_EQ(4, oper.getSubexpressions().size());
+ // Now, the last one kills it, but the first ones will run, the fourth
+ // won't
+ EXPECT_EQ(!emptyResult, oper.matches(log));
+ log.checkFirst(3);
+}
+
+TEST(LogicOperators, AllOf) {
+ testCheck<AllOfSpec>(true);
+}
+
+TEST(LogicOperators, AnyOf) {
+ testCheck<AnyOfSpec>(false);
+}
+
+// Fixture for the tests of the creators
+class LogicCreatorTest : public ::testing::Test {
+private:
+ typedef shared_ptr<Loader<Log>::CheckCreator> CreatorPtr;
+public:
+ // Register some creators, both tested ones and some auxiliary ones for
+ // help
+ LogicCreatorTest():
+ loader_(REJECT)
+ {
+ loader_.registerCreator(CreatorPtr(new
+ LogicCreator<AnyOfSpec, Log>("ANY")));
+ loader_.registerCreator(CreatorPtr(new
+ LogicCreator<AllOfSpec, Log>("ALL")));
+ loader_.registerCreator(CreatorPtr(new ThrowCreator));
+ loader_.registerCreator(CreatorPtr(new LogCreator));
+ }
+ // To mark which parts of the check did run
+ Log log_;
+ // The loader
+ Loader<Log> loader_;
+ // Some convenience shortcut names
+ typedef LogicOperator<AnyOfSpec, Log> AnyOf;
+ typedef LogicOperator<AllOfSpec, Log> AllOf;
+ typedef shared_ptr<AnyOf> AnyOfPtr;
+ typedef shared_ptr<AllOf> AllOfPtr;
+ // Loads the JSON as a check and tries to convert it to the given check
+ // subclass
+ template<typename Result> shared_ptr<Result> load(const string& JSON) {
+ shared_ptr<Check<Log> > result;
+ EXPECT_NO_THROW(result = loader_.loadCheck(el(JSON)));
+ shared_ptr<Result>
+ resultConverted(dynamic_pointer_cast<Result>(result));
+ EXPECT_NE(shared_ptr<Result>(), resultConverted);
+ return (resultConverted);
+ }
+};
+
+// Test it can load empty ones
+TEST_F(LogicCreatorTest, empty) {
+ AnyOfPtr emptyAny(load<AnyOf>("{\"ANY\": []}"));
+ EXPECT_EQ(0, emptyAny->getSubexpressions().size());
+ AllOfPtr emptyAll(load<AllOf>("{\"ALL\": []}"));
+ EXPECT_EQ(0, emptyAll->getSubexpressions().size());
+}
+
+// Test it rejects invalid inputs (not a list as a parameter)
+TEST_F(LogicCreatorTest, invalid) {
+ EXPECT_THROW(loader_.loadCheck(el("{\"ANY\": null}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ANY\": {}}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ANY\": true}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ANY\": 42}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ANY\": \"hello\"}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ALL\": null}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ALL\": {}}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ALL\": true}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ALL\": 42}")), LoaderError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ALL\": \"hello\"}")), LoaderError);
+}
+
+// Exceptions from subexpression creation isn't caught
+TEST_F(LogicCreatorTest, propagate) {
+ EXPECT_THROW(loader_.loadCheck(el("{\"ANY\": [{\"throw\": null}]}")),
+ TestCreatorError);
+ EXPECT_THROW(loader_.loadCheck(el("{\"ALL\": [{\"throw\": null}]}")),
+ TestCreatorError);
+}
+
+// We can create more complex ANY check and run it correctly
+TEST_F(LogicCreatorTest, anyRun) {
+ AnyOfPtr any(load<AnyOf>("{\"ANY\": ["
+ " {\"logcheck\": [0, false]},"
+ " {\"logcheck\": [1, true]},"
+ " {\"logcheck\": [2, true]}"
+ "]}"));
+ EXPECT_EQ(3, any->getSubexpressions().size());
+ EXPECT_TRUE(any->matches(log_));
+ log_.checkFirst(2);
+}
+
+// We can create more complex ALL check and run it correctly
+TEST_F(LogicCreatorTest, allRun) {
+ AllOfPtr any(load<AllOf>("{\"ALL\": ["
+ " {\"logcheck\": [0, true]},"
+ " {\"logcheck\": [1, false]},"
+ " {\"logcheck\": [2, false]}"
+ "]}"));
+ EXPECT_EQ(3, any->getSubexpressions().size());
+ EXPECT_FALSE(any->matches(log_));
+ log_.checkFirst(2);
+}
+
+// Or is able to return false
+TEST_F(LogicCreatorTest, anyFalse) {
+ AnyOfPtr any(load<AnyOf>("{\"ANY\": ["
+ " {\"logcheck\": [0, false]},"
+ " {\"logcheck\": [1, false]},"
+ " {\"logcheck\": [2, false]}"
+ "]}"));
+ EXPECT_EQ(3, any->getSubexpressions().size());
+ EXPECT_FALSE(any->matches(log_));
+ log_.checkFirst(3);
+}
+
+// And is able to return true
+TEST_F(LogicCreatorTest, andTrue) {
+ AllOfPtr all(load<AllOf>("{\"ALL\": ["
+ " {\"logcheck\": [0, true]},"
+ " {\"logcheck\": [1, true]},"
+ " {\"logcheck\": [2, true]}"
+ "]}"));
+ EXPECT_EQ(3, all->getSubexpressions().size());
+ EXPECT_TRUE(all->matches(log_));
+ log_.checkFirst(3);
+}
+
+// We can nest them together
+TEST_F(LogicCreatorTest, nested) {
+ AllOfPtr all(load<AllOf>("{\"ALL\": ["
+ " {\"ANY\": ["
+ " {\"logcheck\": [0, true]},"
+ " {\"logcheck\": [2, true]},"
+ " ]},"
+ " {\"logcheck\": [1, false]}"
+ "]}"));
+ EXPECT_EQ(2, all->getSubexpressions().size());
+ const LogicOperator<AnyOfSpec, Log>*
+ any(dynamic_cast<const LogicOperator<AnyOfSpec, Log>*>
+ (all->getSubexpressions()[0]));
+ EXPECT_EQ(2, any->getSubexpressions().size());
+ EXPECT_FALSE(all->matches(log_));
+ log_.checkFirst(2);
+}
+
+}
More information about the bind10-changes
mailing list