BIND 10 trac494, updated. cf6de64ab83a1db3a71aa065c1d247462f236ea8 [trac494] more docs
BIND 10 source code commits
bind10-changes at lists.isc.org
Mon Jan 31 10:56:13 UTC 2011
The branch, trac494 has been updated
via cf6de64ab83a1db3a71aa065c1d247462f236ea8 (commit)
via 5f6cbcc31cc0f16af49dd433ac96da967d200d6c (commit)
via 923977389a20aa0396dccec4867f3721fc95a4bd (commit)
via d8a7320161d314a5863183a063d0e00fdd1017bd (commit)
from f0a43d242f48103eec0703d7081522ec0f2225a9 (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 cf6de64ab83a1db3a71aa065c1d247462f236ea8
Author: Jelte Jansen <jelte at isc.org>
Date: Mon Jan 31 11:54:16 2011 +0100
[trac494] more docs
commit 5f6cbcc31cc0f16af49dd433ac96da967d200d6c
Author: Jelte Jansen <jelte at isc.org>
Date: Mon Jan 31 11:39:28 2011 +0100
[trac494] some documentation
commit 923977389a20aa0396dccec4867f3721fc95a4bd
Author: Jelte Jansen <jelte at isc.org>
Date: Mon Jan 31 10:56:55 2011 +0100
[trac494] remove 'Direct' callback holder
now that AbstractResolverCallback wqas removed, the 'direct' callback
holder class is not necessary anymore (callers can derive from
ResolverInterface::Callback now)
commit d8a7320161d314a5863183a063d0e00fdd1017bd
Author: Jelte Jansen <jelte at isc.org>
Date: Mon Jan 31 10:19:17 2011 +0100
[trac494] maka interface the same
(so we can remove one of them)
-----------------------------------------------------------------------
Summary of changes:
src/lib/asiolink/asiolink.cc | 18 ++++---
src/lib/asiolink/asiolink.h | 40 ++++++++++++---
src/lib/resolve/resolver_callback.cc | 29 +++--------
src/lib/resolve/resolver_callback.h | 42 +++++----------
src/lib/resolve/resolver_interface.h | 91 ++++++++++++++++++++-------------
5 files changed, 118 insertions(+), 102 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/asiolink/asiolink.cc b/src/lib/asiolink/asiolink.cc
index 748f8b3..fbbcc86 100644
--- a/src/lib/asiolink/asiolink.cc
+++ b/src/lib/asiolink/asiolink.cc
@@ -357,7 +357,7 @@ private:
// Server to notify when we succeed or fail
//shared_ptr<DNSServer> server_;
- isc::resolve::AbstractResolverCallback* resolvercallback_;
+ isc::resolve::ResolverInterface::CallbackPtr resolvercallback_;
/*
* TODO Do something more clever with timeouts. In the long term, some
@@ -480,7 +480,7 @@ public:
shared_ptr<AddressVector> upstream_root,
OutputBufferPtr buffer,
//DNSServer* server,
- isc::resolve::AbstractResolverCallback* cb,
+ isc::resolve::ResolverInterface::CallbackPtr cb,
int timeout,
unsigned retries) :
io_(io),
@@ -540,7 +540,7 @@ public:
}
if (done) {
- resolvercallback_->callback(result == UDPQuery::SUCCESS);
+ resolvercallback_->success(answer_message_);
//server_->resume(result == UDPQuery::SUCCESS);
delete this;
}
@@ -550,7 +550,7 @@ public:
send();
} else {
// out of retries, give up for now
- resolvercallback_->callback(false);
+ resolvercallback_->failure();
//server_->resume(false);
delete this;
}
@@ -566,15 +566,17 @@ RecursiveQuery::sendQuery(const isc::dns::QuestionPtr& question,
asio::io_service& io = dns_service_.get_io_service();
MessagePtr answer_message(new Message(Message::RENDER));
- answer_message->setOpcode(isc::dns::Opcode::QUERY());
OutputBufferPtr buffer(new OutputBuffer(0));
+ /*
+ answer_message->setOpcode(isc::dns::Opcode::QUERY());
isc::resolve::ResolverCallbackDirect* rcd =
new isc::resolve::ResolverCallbackDirect(callback,
answer_message);
+ */
// It will delete itself when it is done
new RunningQuery(io, *question, answer_message, upstream_,
- upstream_root_, buffer, rcd, timeout_, retries_);
+ upstream_root_, buffer, callback, timeout_, retries_);
}
void
@@ -589,8 +591,8 @@ RecursiveQuery::sendQuery(const Question& question,
// we're only going to handle UDP.
asio::io_service& io = dns_service_.get_io_service();
- isc::resolve::ResolverCallbackServer* crs =
- new isc::resolve::ResolverCallbackServer(server);
+ isc::resolve::ResolverInterface::CallbackPtr crs(
+ new isc::resolve::ResolverCallbackServer(server));
// It will delete itself when it is done
new RunningQuery(io, question, answer_message, upstream_,
diff --git a/src/lib/asiolink/asiolink.h b/src/lib/asiolink/asiolink.h
index 89cb8f5..cc97417 100644
--- a/src/lib/asiolink/asiolink.h
+++ b/src/lib/asiolink/asiolink.h
@@ -533,11 +533,13 @@ class RecursiveQuery {
///
//@{
public:
- /// \brief Constructor for use when acting as a forwarder
+ /// \brief Constructor
///
/// This is currently the only way to construct \c RecursiveQuery
- /// object. The addresses of the forward nameservers is specified,
- /// and every upstream query will be sent to one random address.
+ /// object. If the addresses of the forward nameservers is specified,
+ /// and every upstream query will be sent to one random address, and
+ /// the result sent back directly. If not, it will do full resolving.
+ ///
/// \param dns_service The DNS Service to perform the recursive
/// query on.
/// \param upstream Addresses and ports of the upstream servers
@@ -557,19 +559,39 @@ public:
int timeout = -1, unsigned retries = 0);
//@}
+ /// \brief Initiate resolving
+ ///
+ /// When sendQuery() is called, a (set of) message(s) is sent
+ /// asynchronously. If upstream servers are set, one is chosen
+ /// and the response (if any) from that server will be returned.
+ ///
+ /// If not upstream is set, a root server is chosen from the
+ /// root_servers, and the RunningQuery shall do a full resolve
+ /// (i.e. if the answer is a delegation, it will be followed, etc.)
+ /// until there is an answer or an error.
+ ///
+ /// When there is a response or an error and we give up, the given
+ /// CallbackPtr object shall be called (with either success() or
+ /// failure(). See ResolverInterface::Callback for more information.
+ ///
+ /// \param question The question being answered <qname/qclass/qtype>
+ /// \param callback Callback object
+ /// \param buffer An output Message into which the final response will be copied
+ /// \param buffer An output buffer into which the intermediate responses will be copied
+ /// \param server A pointer to the \c DNSServer object handling the client
void sendQuery(const isc::dns::QuestionPtr& question,
const isc::resolve::ResolverInterface::CallbackPtr callback);
- /// \brief Initiates an upstream query in the \c RecursiveQuery object.
+ /// \brief Initiates resolving for the given question.
///
- /// When sendQuery() is called, a message is sent asynchronously to
- /// the upstream name server. When a reply arrives, 'server'
- /// is placed on the ASIO service queue via io_service::post(), so
- /// that the original \c DNSServer objct can resume processing.
+ /// This actually calls the previous sendQuery() with a default
+ /// callback object, which calls resume() on the given DNSServer
+ /// object.
///
/// \param question The question being answered <qname/qclass/qtype>
- /// \param buffer An output buffer into which the response can be copied
+ /// \param buffer An output Message into which the final response will be copied
+ /// \param buffer An output buffer into which the intermediate responses will be copied
/// \param server A pointer to the \c DNSServer object handling the client
void sendQuery(const isc::dns::Question& question,
isc::dns::MessagePtr answer_message,
diff --git a/src/lib/resolve/resolver_callback.cc b/src/lib/resolve/resolver_callback.cc
index 849f59c..c0db55e 100644
--- a/src/lib/resolve/resolver_callback.cc
+++ b/src/lib/resolve/resolver_callback.cc
@@ -18,31 +18,18 @@ namespace isc {
namespace resolve {
void
-ResolverCallbackServer::callback(bool result) {
- server_->resume(result);
- delete server_;
- delete this;
+ResolverCallbackServer::success(const isc::dns::MessagePtr response)
+{
+ // ignore our response here
+ (void)response;
+
+ server_->resume(true);
}
void
-ResolverCallbackDirect::callback(bool result)
+ResolverCallbackServer::failure()
{
- // simply return with the first rrset from answer right now
- if (result &&
- answer_message_->getRcode() == isc::dns::Rcode::NOERROR() &&
- answer_message_->getRRCount(isc::dns::Message::SECTION_ANSWER) > 0) {
- /*
- std::cout << *answer_message_ << std::endl;
- isc::dns::RRsetIterator rrsi = answer_message_->beginSection(isc::dns::Message::SECTION_ANSWER);
- const isc::dns::RRsetPtr result = *rrsi;
- callback_->success(result);
- */
- callback_->success(answer_message_);
- } else {
- callback_->failure();
- }
- // once called back we don't need ourselves anymore
- delete this;
+ server_->resume(false);
}
} // namespace resolve
diff --git a/src/lib/resolve/resolver_callback.h b/src/lib/resolve/resolver_callback.h
index 0abf54f..f69d8a7 100644
--- a/src/lib/resolve/resolver_callback.h
+++ b/src/lib/resolve/resolver_callback.h
@@ -16,46 +16,32 @@
#define _ISC_RESOLVER_CALLBACK_H 1
#include <asiolink/asiolink.h>
+#include <dns/message.h>
namespace isc {
namespace resolve {
-// We define two types of callbackholders for processing recursive
-// queries; one calls back the original DNSServer to resume()
-// the other uses direct callbacks (for instance when we need to
-// resolve something ourselves)
-// Caller warning: only callback once! The objects will delete
-// themselves on callback (after they have done they callback)
-class AbstractResolverCallback {
-public:
- ~AbstractResolverCallback() {};
- virtual void callback(bool result) = 0;
-};
-
-class ResolverCallbackServer : public AbstractResolverCallback {
+/// \short Standard Callback for sendQuery for DNSServer instances
+///
+/// This is a standard ResolverInterface::Callback implementation
+/// that is used by Resolver; when RunningQuery finishes and has either
+/// some data or an error, DNSServer::resume() will be called.
+///
+/// This class will ignore the response MessagePtr in the callback,
+/// as the server itself should also have a reference.
+class ResolverCallbackServer : public ResolverInterface::Callback {
public:
ResolverCallbackServer(asiolink::DNSServer* server) :
server_(server->clone()) {}
- void callback(bool result);
+ ~ResolverCallbackServer() { delete server_; };
+
+ void success(const isc::dns::MessagePtr response);
+ void failure();
private:
asiolink::DNSServer* server_;
};
-class ResolverCallbackDirect : public AbstractResolverCallback {
-public:
- ResolverCallbackDirect(
- const isc::resolve::ResolverInterface::CallbackPtr callback,
- isc::dns::MessagePtr answer_message) :
- callback_(callback),
- answer_message_(answer_message) {}
- void callback(bool result);
-
-private:
- const isc::resolve::ResolverInterface::CallbackPtr callback_;
- isc::dns::MessagePtr answer_message_;
-};
-
} //namespace resolve
} //namespace isc
diff --git a/src/lib/resolve/resolver_interface.h b/src/lib/resolve/resolver_interface.h
index 6cf1674..e08bb64 100644
--- a/src/lib/resolve/resolver_interface.h
+++ b/src/lib/resolve/resolver_interface.h
@@ -16,59 +16,78 @@
#define __RESOLVER_INTERFACE_H
#include <dns/message.h>
-#include <dns/rrset.h>
-/**
- * \file resolver_interface.h
- * \short Temporary interface to resolver.
- *
- * This file contains a dummy interface for the resolver, which does not yet
- * exist. When the resolver appears, this file should either wrap its
- * interface or, better, be removed completely.
- *
- * Currently left in while moving interfaces and classes around
- */
+///
+/// \file resolver_interface.h
+/// \short Interface to resolver.
+///
+/// This file contains an interface for the resolver. By subclassing
+/// this abstract interface, other parts of the system can ask the
+/// resolver to do some resolving too.
+///
+/// This is done by creating a subclass of ResolverInterface::Callback,
+/// which defines what to do with the result, and then calling resolve()
+/// on the ResolverInterface implementation.
+///
+/// One default Callback subclass is provided right now, in
+/// resolver_callback.[h|cc], which calls resumse() on a given DNSServer
+///
namespace isc {
namespace resolve {
-/**
- * \short Abstract interface to the resolver.
- *
- * Abstract interface to the resolver. The NameserverAddressStore uses this
- * to ask for addresses. It is here because resolver does not yet exist.
- *
- * It is abstract to allow tests pass dummy resolvers.
- */
+///
+/// \short Abstract interface to the resolver.
+///
+/// Abstract interface to the resolver. The NameserverAddressStore uses this
+/// to ask for addresses. It is here because resolver does not yet exist.
+///
+/// It is abstract to allow tests pass dummy resolvers.
+///
class ResolverInterface {
public:
- /// \short An abstract callback when data from resolver are ready.
+ /// \short An abstract callback for when the resolver is done.
+ ///
+ /// You can pass an instance of a subclass of this (as a
+ /// CallbackPtr) to RecursiveQuery::sendQuery(), and when it
+ /// is done, it will either call success() if there is an
+ /// answer MessagePtr, or failure(), if the resolver was not
+ /// able to find anything.
+ ///
+ /// Note that a result Message does not necessarily contain
+ /// the actual answer (it could be a noerror/nodata response).
class Callback {
public:
/// \short Some data arrived.
- virtual void success(isc::dns::MessagePtr response) = 0;
+ virtual void success(const isc::dns::MessagePtr response) = 0;
- /**
- * \short No data available.
- *
- * \todo Pass some reason.
- */
+ ///
+ ///\short No data available.
+ ///
+ ///\todo Provide error reason (result of the
+ /// classification call, for instance? We'd also
+ /// need some way to say 'everything times out')
+ ///
virtual void failure() = 0;
+
/// \short Virtual destructor, so descendants are cleaned up
- virtual ~ Callback() {};
+ virtual ~Callback() {};
};
+
typedef boost::shared_ptr<Callback> CallbackPtr;
- /**
- * \short Ask a question.
- *
- * Asks the resolver a question. Once the answer is ready
- * the callback is called.
- *
- * \param question What to ask. The resolver will decide who.
- * \param callback What should happen when the answer is ready.
- */
+
+ ///
+ ///\short Ask a question.
+ ///
+ /// Asks the resolver a question. Once the answer is ready
+ /// the callback is called.
+ ///
+ /// \param question What to ask. The resolver will decide who.
+ /// \param callback What should happen when the answer is ready.
+ ///
virtual void resolve(const isc::dns::QuestionPtr& question,
const CallbackPtr& callback) = 0;
+
/// \short Virtual destructor, so descendants are properly cleaned up
virtual ~ ResolverInterface() {}
};
More information about the bind10-changes
mailing list