Make UeberBackend::handle even more opaque. NFCI

Signed-off-by: Miod Vallat <[email protected]>

Author: miodvallat

pdns/ueberbackend.cc

@@ -715,6 +715,8 @@ UeberBackend::UeberBackend(const string& pname)
   d_negcache_ttl = ::arg().asNum("negquery-cache-ttl");
 
   backends = BackendMakers().all(pname == "key-only");
+
+  d_handle.setParent(this);
 }
 
 // returns -1 for miss, 0 for negative match, 1 for hit
@@ -806,22 +808,15 @@ void UeberBackend::lookup(const QType& qtype, const DNSName& qname, domainid_t z
 
   d_qtype = qtype.getCode();
 
-  d_handle.parent = this;
-  d_handle.backendIndex = 0;
-  d_handle.qtype = s_doANYLookupsOnly ? QType::ANY : qtype;
-  d_handle.qname = qname;
-  d_handle.zoneId = zoneId;
-  d_handle.pkt_p = pkt_p;
+  d_handle.lookup(qtype, qname, zoneId, pkt_p);
 
   if (backends.empty()) {
     g_log << Logger::Error << "No database backends available - unable to answer questions." << endl;
     d_stale = true; // please recycle us!
     throw PDNSException("We are stale, please recycle");
   }
 
-  d_question.qtype = d_handle.qtype;
-  d_question.qname = qname;
-  d_question.zoneId = d_handle.zoneId;
+  d_handle.setupQuestion(d_question);
 
   auto cacheResult = cacheHas(d_question, d_answers);
   if (cacheResult == CacheResult::Miss) { // nothing
@@ -1063,14 +1058,30 @@ void UeberBackend::flush()
   }
 }
 
+void UeberBackend::handle::lookup(const QType& qtype, const DNSName& qname, domainid_t zoneId, DNSPacket* pkt_p)
+{
+  d_backendIndex = 0;
+  d_qtype = s_doANYLookupsOnly ? QType::ANY : qtype;
+  d_qname = qname;
+  d_zoneId = zoneId;
+  d_pkt_p = pkt_p;
+}
+
+void UeberBackend::handle::setupQuestion(UeberBackend::Question& question) const
+{
+  question.qtype = d_qtype;
+  question.qname = d_qname;
+  question.zoneId = d_zoneId;
+}
+
 // Set d_hinterBackend to the next available backend from the parents list,
 // reset it to nullptr if the whole list has been processed.
 // Invokes lookup on behalf of the newly picked backend if successful.
 void UeberBackend::handle::selectNextBackend()
 {
-  if (backendIndex < parent->backends.size()) {
-    d_hinterBackend = parent->backends[backendIndex++].get();
-    d_hinterBackend->lookup(qtype, qname, zoneId, pkt_p);
+  if (d_backendIndex < d_parent->backends.size()) {
+    d_hinterBackend = d_parent->backends[d_backendIndex++].get();
+    d_hinterBackend->lookup(d_qtype, d_qname, d_zoneId, d_pkt_p);
     ++(*s_backendQueries);
   }
   else {
@@ -1082,11 +1093,11 @@ bool UeberBackend::handle::get(DNSZoneRecord& record)
 {
   DLOG(g_log << "Ueber get() was called for a " << qtype << " record" << endl);
   while (d_hinterBackend != nullptr && !(d_hinterBackend->get(record))) { // this backend is out of answers
-    DLOG(g_log << "Backend #" << backendIndex << " of " << parent->backends.size()
+    DLOG(g_log << "Backend #" << d_backendIndex << " of " << d_parent->backends.size()
                << " out of answers, trying next" << endl);
     selectNextBackend();
     if (d_hinterBackend != nullptr) {
-      DLOG(g_log << "Now asking backend #" << backendIndex << endl);
+      DLOG(g_log << "Now asking backend #" << d_backendIndex << endl);
     }
   }
 
@@ -1096,7 +1107,7 @@ bool UeberBackend::handle::get(DNSZoneRecord& record)
   }
 
   DLOG(g_log << "Found an answering backend - will not try another one" << endl);
-  backendIndex = parent->backends.size(); // don't go on to the next backend
+  d_backendIndex = d_parent->backends.size(); // don't go on to the next backend
   return true;
 }
 

pdns/ueberbackend.hh

@@ -62,30 +62,36 @@ public:
       new modules are loaded */
   vector<std::unique_ptr<DNSBackend>> backends;
 
+  struct Question;
+
   //! the very magic handle for UeberBackend questions
   class handle
   {
   public:
+    void setParent(UeberBackend* parent) { d_parent = parent; }
+    void selectNextBackend();
+
+    void setupQuestion(Question& question) const;
+    void lookup(const QType& qtype, const DNSName& qname, domainid_t zoneId, DNSPacket* pkt_p);
     bool get(DNSZoneRecord& record);
     void lookupEnd() const;
 
+  private:
     //! The UeberBackend class where this handle belongs to
-    UeberBackend* parent{nullptr};
+    UeberBackend* d_parent{nullptr};
 
-    //! DNSPacket who asked this question
-    DNSPacket* pkt_p{nullptr};
-    DNSName qname;
+    //! The currently selected real backend, which is answering questions
+    DNSBackend* d_hinterBackend{nullptr};
 
     //! Index of the current backend within the backends vector
-    size_t backendIndex{0};
-    QType qtype;
-    domainid_t zoneId{UnknownDomainID};
+    size_t d_backendIndex{0};
 
-    void selectNextBackend();
+    //! DNSPacket who asked this question
+    DNSPacket* d_pkt_p{nullptr};
+    DNSName d_qname;
 
-  private:
-    //! The currently selected real backend, which is answering questions
-    DNSBackend* d_hinterBackend{nullptr};
+    QType d_qtype;
+    domainid_t d_zoneId{UnknownDomainID};
   };
 
   void lookup(const QType& qtype, const DNSName& qname, domainid_t zoneId, DNSPacket* pkt_p = nullptr);