11163303031

Committed 03 Oct 2024 01:50PM UTC coverage: 64.733% (+0.01%) from 64.721%

Build # 11163303031

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14739 from rgacogne/ddist-disable-ebpf-for-quic

dnsdist: Disable eBPF filtering on QUIC (DoQ, DoH3) sockets

Run Details

37113 of 88044 branches covered (42.15%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

59 existing lines in 6 files now uncovered.

125017 of 162417 relevant lines covered (76.97%)

4783747.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.14

/pdns/recursordist/rec-taskqueue.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "rec-taskqueue.hh"
#include "taskqueue.hh"
#include "lock.hh"
#include "logging.hh"
#include "stat_t.hh"
#include "syncres.hh"

// For rate limiting purposes we maintain a set of tasks recently submitted.
class TimedSet
{
public:
  TimedSet(time_t time) :
    d_expiry_seconds(time)
  {
  }

  uint64_t purge(time_t now)
  {
    // This purge is relatively cheap, as we're walking an ordered index
    uint64_t erased = 0;
    auto& ind = d_set.template get<time_t>();
    auto iter = ind.begin();
    while (iter != ind.end()) {
      if (iter->d_ttd < now) {
        ++erased;
        iter = ind.erase(iter);
      }
      else {
        break;
      }
    }
    return erased;
  }

  bool insert(time_t now, const pdns::ResolveTask& task)
  {
    // We periodically purge
    if (++d_count % 1024 == 0) {
      purge(now);
    }
    time_t ttd = now + d_expiry_seconds;
    bool inserted = d_set.emplace(task, ttd).second;
    if (!inserted) {
      uint64_t erased = purge(now);
      // Try again if the purge deleted at least one entry
      if (erased > 0) {
        inserted = d_set.emplace(task, ttd).second;
      }
    }
    return inserted;
  }

  void clear()
  {
    d_set.clear();
  }

private:
  struct Entry
  {
    Entry(pdns::ResolveTask task, time_t ttd) :
      d_task(std::move(task)), d_ttd(ttd) {}
    pdns::ResolveTask d_task;
    time_t d_ttd;
  };

  using timed_set_t = multi_index_container<
    Entry,
    indexed_by<ordered_unique<tag<pdns::ResolveTask>,
                              member<Entry, pdns::ResolveTask, &Entry::d_task>>,
               ordered_non_unique<tag<time_t>,
                                  member<Entry, time_t, &Entry::d_ttd>>>>;
  timed_set_t d_set;
  time_t d_expiry_seconds;
  unsigned int d_count{0};
};

struct Queue
{
  pdns::TaskQueue queue;
  TimedSet rateLimitSet{60};
};
static LockGuarded<Queue> s_taskQueue;

struct taskstats
{
  pdns::stat_t pushed;
  pdns::stat_t run;
  pdns::stat_t exceptions;
};

static struct taskstats s_almost_expired_tasks;
static struct taskstats s_resolve_tasks;

// forceNoQM is true means resolve using no qm, false means use default value
static void resolveInternal(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task, bool forceNoQM) noexcept
{
  auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(task.d_qname), "qtype", Logging::Loggable(QType(task.d_qtype).toString()), "netmask", Logging::Loggable(task.d_netmask.empty() ? "" : task.d_netmask.toString()));
  const string msg = "Exception while running a background ResolveTask";
  SyncRes resolver(now);
  vector<DNSRecord> ret;
  resolver.setRefreshAlmostExpired(task.d_refreshMode);
  resolver.setQuerySource(task.d_netmask);
  if (forceNoQM) {
    resolver.setQNameMinimization(false);
  }
  bool exceptionOccurred = true;
  try {
    log->info(Logr::Debug, "resolving", "refresh", Logging::Loggable(task.d_refreshMode));
    int res = resolver.beginResolve(task.d_qname, QType(task.d_qtype), QClass::IN, ret);
    exceptionOccurred = false;
    log->info(Logr::Debug, "done", "rcode", Logging::Loggable(res), "records", Logging::Loggable(ret.size()));
  }
  catch (const std::exception& e) {
    log->error(Logr::Warning, msg, e.what());
  }
  catch (const PDNSException& e) {
    log->error(Logr::Warning, msg, e.reason);
  }
  catch (const ImmediateServFailException& e) {
    if (logErrors) {
      log->error(Logr::Warning, msg, e.reason);
    }
  }
  catch (const PolicyHitException& e) {
    if (logErrors) {
      log->error(Logr::Warning, msg, "PolicyHit");
    }
  }
  catch (...) {
    log->error(Logr::Warning, msg, "Unexpected exception");
  }
  if (exceptionOccurred) {
    if (task.d_refreshMode) {
      ++s_almost_expired_tasks.exceptions;
    }
    else {
      ++s_resolve_tasks.exceptions;
    }
  }
  else {
    if (task.d_refreshMode) {
      ++s_almost_expired_tasks.run;
    }
    else {
      ++s_resolve_tasks.run;
    }
  }
}

static void resolveForceNoQM(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task) noexcept
{
  resolveInternal(now, logErrors, task, true);
}

static void resolve(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task) noexcept
{
  resolveInternal(now, logErrors, task, false);
}

static void tryDoT(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task) noexcept
{
  auto log = g_slog->withName("taskq")->withValues("method", Logging::Loggable("tryDoT"), "name", Logging::Loggable(task.d_qname), "qtype", Logging::Loggable(QType(task.d_qtype).toString()), "ip", Logging::Loggable(task.d_ip));
  const string msg = "Exception while running a background tryDoT task";
  SyncRes resolver(now);
  vector<DNSRecord> ret;
  resolver.setRefreshAlmostExpired(false);
  bool exceptionOccurred = true;
  try {
    log->info(Logr::Debug, "trying DoT");
    bool tryOK = resolver.tryDoT(task.d_qname, QType(task.d_qtype), task.d_nsname, task.d_ip, now.tv_sec);
    exceptionOccurred = false;
    log->info(Logr::Debug, "done", "ok", Logging::Loggable(tryOK));
  }
  catch (const std::exception& e) {
    log->error(Logr::Warning, msg, e.what());
  }
  catch (const PDNSException& e) {
    log->error(Logr::Warning, msg, e.reason);
  }
  catch (const ImmediateServFailException& e) {
    if (logErrors) {
      log->error(Logr::Warning, msg, e.reason);
    }
  }
  catch (const PolicyHitException& e) {
    if (logErrors) {
      log->error(Logr::Notice, msg, "PolicyHit");
    }
  }
  catch (...) {
    log->error(Logr::Warning, msg, "Unexpected exception");
  }
  if (exceptionOccurred) {
    ++s_resolve_tasks.exceptions;
  }
  else {
    ++s_resolve_tasks.run;
  }
}

void runTasks(size_t max, bool logErrors)
{
  for (size_t count = 0; count < max; count++) {
    if (!runTaskOnce(logErrors)) {
      // No more tasks in queue
      break;
    }
  }
}

bool runTaskOnce(bool logErrors)
{
  pdns::ResolveTask task;
  {
    auto lock = s_taskQueue.lock();
    if (lock->queue.empty()) {
      return false;
    }
    task = lock->queue.pop();
  }
  bool expired = task.run(logErrors);
  if (expired) {
    s_taskQueue.lock()->queue.incExpired();
  }
  return true;
}

void pushAlmostExpiredTask(const DNSName& qname, uint16_t qtype, time_t deadline, const Netmask& netmask)
{
  if (SyncRes::isUnsupported(qtype)) {
    auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(qname), "qtype", Logging::Loggable(QType(qtype).toString()), "netmask", Logging::Loggable(netmask.empty() ? "" : netmask.toString()));
    log->error(Logr::Error, "Cannot push task", "qtype unsupported");
    return;
  }
  pdns::ResolveTask task{qname, qtype, deadline, true, resolve, {}, {}, netmask};
  if (s_taskQueue.lock()->queue.push(std::move(task))) {
    ++s_almost_expired_tasks.pushed;
  }
}

void pushResolveTask(const DNSName& qname, uint16_t qtype, time_t now, time_t deadline, bool forceQMOff)
{
  if (SyncRes::isUnsupported(qtype)) {
    auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(qname), "qtype", Logging::Loggable(QType(qtype).toString()));
    log->error(Logr::Error, "Cannot push task", "qtype unsupported");
    return;
  }
  auto func = forceQMOff ? resolveForceNoQM : resolve;
  pdns::ResolveTask task{qname, qtype, deadline, false, func, {}, {}, {}};
  auto lock = s_taskQueue.lock();
  bool inserted = lock->rateLimitSet.insert(now, task);
  if (inserted) {
    if (lock->queue.push(std::move(task))) {
      ++s_resolve_tasks.pushed;
    }
  }
}

bool pushTryDoTTask(const DNSName& qname, uint16_t qtype, const ComboAddress& ipAddress, time_t deadline, const DNSName& nsname)
{
  if (SyncRes::isUnsupported(qtype)) {
    auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(qname), "qtype", Logging::Loggable(QType(qtype).toString()));
    log->error(Logr::Error, "Cannot push task", "qtype unsupported");
    return false;
  }

  pdns::ResolveTask task{qname, qtype, deadline, false, tryDoT, ipAddress, nsname, {}};
  bool pushed = s_taskQueue.lock()->queue.push(std::move(task));
  if (pushed) {
    ++s_almost_expired_tasks.pushed;
  }
  return pushed;
}

uint64_t getTaskPushes()
{
  return s_taskQueue.lock()->queue.getPushes();
}

uint64_t getTaskExpired()
{
  return s_taskQueue.lock()->queue.getExpired();
}

uint64_t getTaskSize()
{
  return s_taskQueue.lock()->queue.size();
}

void taskQueueClear()
{
  auto lock = s_taskQueue.lock();
  lock->queue.clear();
  lock->rateLimitSet.clear();
}

pdns::ResolveTask taskQueuePop()
{
  return s_taskQueue.lock()->queue.pop();
}

uint64_t getAlmostExpiredTasksPushed()
{
  return s_almost_expired_tasks.pushed;
}

uint64_t getAlmostExpiredTasksRun()
{
  return s_almost_expired_tasks.run;
}

uint64_t getAlmostExpiredTaskExceptions()
{
  return s_almost_expired_tasks.exceptions;
}

uint64_t getResolveTasksPushed()
{
  return s_almost_expired_tasks.pushed;
}

uint64_t getResolveTasksRun()
{
  return s_almost_expired_tasks.run;
}

uint64_t getResolveTaskExceptions()
{
  return s_almost_expired_tasks.exceptions;
}

bool taskQTypeIsSupported(QType qtype)
{
  return !SyncRes::isUnsupported(qtype);
}

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22
23	#include "rec-taskqueue.hh"
24	#include "taskqueue.hh"
25	#include "lock.hh"
26	#include "logging.hh"
27	#include "stat_t.hh"
28	#include "syncres.hh"
29
30	// For rate limiting purposes we maintain a set of tasks recently submitted.
31	class TimedSet
32	{
33	public:
34	TimedSet(time_t time) :
35	d_expiry_seconds(time)
36	{	157✔
37	}	157✔
38
39	uint64_t purge(time_t now)
40	{	556✔
41	// This purge is relatively cheap, as we're walking an ordered index
42	uint64_t erased = 0;	556✔
43	auto& ind = d_set.template get<time_t>();	556✔
44	auto iter = ind.begin();	556✔
45	while (iter != ind.end()) {	558✔
46	if (iter->d_ttd < now) {	556✔
47	++erased;	2✔
48	iter = ind.erase(iter);	2✔
49	}	2✔
50	else {	554✔
51	break;	554✔
52	}	554✔
53	}	556✔
54	return erased;	556✔
55	}	556✔
56
57	bool insert(time_t now, const pdns::ResolveTask& task)
58	{	966✔
59	// We periodically purge
60	if (++d_count % 1024 == 0) {	966!
61	purge(now);	×
62	}	×
63	time_t ttd = now + d_expiry_seconds;	966✔
64	bool inserted = d_set.emplace(task, ttd).second;	966✔
65	if (!inserted) {	966✔
66	uint64_t erased = purge(now);	556✔
67	// Try again if the purge deleted at least one entry
68	if (erased > 0) {	556✔
69	inserted = d_set.emplace(task, ttd).second;	2✔
70	}	2✔
71	}	556✔
72	return inserted;	966✔
73	}	966✔
74
75	void clear()
76	{	600✔
77	d_set.clear();	600✔
78	}	600✔
79
80	private:
81	struct Entry
82	{
83	Entry(pdns::ResolveTask task, time_t ttd) :
84	d_task(std::move(task)), d_ttd(ttd) {}	968✔
85	pdns::ResolveTask d_task;
86	time_t d_ttd;
87	};
88
89	using timed_set_t = multi_index_container<
90	Entry,
91	indexed_by<ordered_unique<tag<pdns::ResolveTask>,
92	member<Entry, pdns::ResolveTask, &Entry::d_task>>,
93	ordered_non_unique<tag<time_t>,
94	member<Entry, time_t, &Entry::d_ttd>>>>;
95	timed_set_t d_set;
96	time_t d_expiry_seconds;
97	unsigned int d_count{0};
98	};
99
100	struct Queue
101	{
102	pdns::TaskQueue queue;
103	TimedSet rateLimitSet{60};
104	};
105	static LockGuarded<Queue> s_taskQueue;
106
107	struct taskstats
108	{
109	pdns::stat_t pushed;
110	pdns::stat_t run;
111	pdns::stat_t exceptions;
112	};
113
114	static struct taskstats s_almost_expired_tasks;
115	static struct taskstats s_resolve_tasks;
116
117	// forceNoQM is true means resolve using no qm, false means use default value
118	static void resolveInternal(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task, bool forceNoQM) noexcept
UNCOV 119	{	×
UNCOV 120	auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(task.d_qname), "qtype", Logging::Loggable(QType(task.d_qtype).toString()), "netmask", Logging::Loggable(task.d_netmask.empty() ? "" : task.d_netmask.toString()));	×
UNCOV 121	const string msg = "Exception while running a background ResolveTask";	×
UNCOV 122	SyncRes resolver(now);	×
UNCOV 123	vector<DNSRecord> ret;	×
UNCOV 124	resolver.setRefreshAlmostExpired(task.d_refreshMode);	×
UNCOV 125	resolver.setQuerySource(task.d_netmask);	×
UNCOV 126	if (forceNoQM) {	×
127	resolver.setQNameMinimization(false);	×
128	}	×
UNCOV 129	bool exceptionOccurred = true;	×
UNCOV 130	try {	×
UNCOV 131	log->info(Logr::Debug, "resolving", "refresh", Logging::Loggable(task.d_refreshMode));	×
UNCOV 132	int res = resolver.beginResolve(task.d_qname, QType(task.d_qtype), QClass::IN, ret);	×
UNCOV 133	exceptionOccurred = false;	×
UNCOV 134	log->info(Logr::Debug, "done", "rcode", Logging::Loggable(res), "records", Logging::Loggable(ret.size()));	×
UNCOV 135	}	×
UNCOV 136	catch (const std::exception& e) {	×
137	log->error(Logr::Warning, msg, e.what());	×
138	}	×
UNCOV 139	catch (const PDNSException& e) {	×
140	log->error(Logr::Warning, msg, e.reason);	×
141	}	×
UNCOV 142	catch (const ImmediateServFailException& e) {	×
143	if (logErrors) {	×
144	log->error(Logr::Warning, msg, e.reason);	×
145	}	×
146	}	×
UNCOV 147	catch (const PolicyHitException& e) {	×
148	if (logErrors) {	×
149	log->error(Logr::Warning, msg, "PolicyHit");	×
150	}	×
151	}	×
UNCOV 152	catch (...) {	×
153	log->error(Logr::Warning, msg, "Unexpected exception");	×
154	}	×
UNCOV 155	if (exceptionOccurred) {	×
156	if (task.d_refreshMode) {	×
157	++s_almost_expired_tasks.exceptions;	×
158	}	×
159	else {	×
160	++s_resolve_tasks.exceptions;	×
161	}	×
162	}	×
UNCOV 163	else {	×
UNCOV 164	if (task.d_refreshMode) {	×
UNCOV 165	++s_almost_expired_tasks.run;	×
UNCOV 166	}	×
167	else {	×
168	++s_resolve_tasks.run;	×
169	}	×
UNCOV 170	}	×
UNCOV 171	}	×
172
173	static void resolveForceNoQM(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task) noexcept
174	{	×
175	resolveInternal(now, logErrors, task, true);	×
176	}	×
177
178	static void resolve(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task) noexcept
UNCOV 179	{	×
UNCOV 180	resolveInternal(now, logErrors, task, false);	×
UNCOV 181	}	×
182
183	static void tryDoT(const struct timeval& now, bool logErrors, const pdns::ResolveTask& task) noexcept
184	{	×
185	auto log = g_slog->withName("taskq")->withValues("method", Logging::Loggable("tryDoT"), "name", Logging::Loggable(task.d_qname), "qtype", Logging::Loggable(QType(task.d_qtype).toString()), "ip", Logging::Loggable(task.d_ip));	×
186	const string msg = "Exception while running a background tryDoT task";	×
187	SyncRes resolver(now);	×
188	vector<DNSRecord> ret;	×
189	resolver.setRefreshAlmostExpired(false);	×
190	bool exceptionOccurred = true;	×
191	try {	×
192	log->info(Logr::Debug, "trying DoT");	×
193	bool tryOK = resolver.tryDoT(task.d_qname, QType(task.d_qtype), task.d_nsname, task.d_ip, now.tv_sec);	×
194	exceptionOccurred = false;	×
195	log->info(Logr::Debug, "done", "ok", Logging::Loggable(tryOK));	×
196	}	×
197	catch (const std::exception& e) {	×
198	log->error(Logr::Warning, msg, e.what());	×
199	}	×
200	catch (const PDNSException& e) {	×
201	log->error(Logr::Warning, msg, e.reason);	×
202	}	×
203	catch (const ImmediateServFailException& e) {	×
204	if (logErrors) {	×
205	log->error(Logr::Warning, msg, e.reason);	×
206	}	×
207	}	×
208	catch (const PolicyHitException& e) {	×
209	if (logErrors) {	×
210	log->error(Logr::Notice, msg, "PolicyHit");	×
211	}	×
212	}	×
213	catch (...) {	×
214	log->error(Logr::Warning, msg, "Unexpected exception");	×
215	}	×
216	if (exceptionOccurred) {	×
217	++s_resolve_tasks.exceptions;	×
218	}	×
219	else {	×
220	++s_resolve_tasks.run;	×
221	}	×
222	}	×
223
224	void runTasks(size_t max, bool logErrors)
225	{	336✔
226	for (size_t count = 0; count < max; count++) {	336!
227	if (!runTaskOnce(logErrors)) {	336!
228	// No more tasks in queue
229	break;	336✔
230	}	336✔
231	}	336✔
232	}	336✔
233
234	bool runTaskOnce(bool logErrors)
235	{	2,698✔
236	pdns::ResolveTask task;	2,698✔
237	{	2,698✔
238	auto lock = s_taskQueue.lock();	2,698✔
239	if (lock->queue.empty()) {	2,698!
240	return false;	2,698✔
241	}	2,698✔
UNCOV 242	task = lock->queue.pop();	×
UNCOV 243	}	×
244	bool expired = task.run(logErrors);	×
UNCOV 245	if (expired) {	×
246	s_taskQueue.lock()->queue.incExpired();	×
247	}	×
UNCOV 248	return true;	×
249	}	2,698✔
250
251	void pushAlmostExpiredTask(const DNSName& qname, uint16_t qtype, time_t deadline, const Netmask& netmask)
252	{	52✔
253	if (SyncRes::isUnsupported(qtype)) {	52!
254	auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(qname), "qtype", Logging::Loggable(QType(qtype).toString()), "netmask", Logging::Loggable(netmask.empty() ? "" : netmask.toString()));	×
255	log->error(Logr::Error, "Cannot push task", "qtype unsupported");	×
256	return;	×
257	}	×
258	pdns::ResolveTask task{qname, qtype, deadline, true, resolve, {}, {}, netmask};	52✔
259	if (s_taskQueue.lock()->queue.push(std::move(task))) {	52✔
260	++s_almost_expired_tasks.pushed;	38✔
261	}	38✔
262	}	52✔
263
264	void pushResolveTask(const DNSName& qname, uint16_t qtype, time_t now, time_t deadline, bool forceQMOff)
265	{	966✔
266	if (SyncRes::isUnsupported(qtype)) {	966!
267	auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(qname), "qtype", Logging::Loggable(QType(qtype).toString()));	×
268	log->error(Logr::Error, "Cannot push task", "qtype unsupported");	×
269	return;	×
270	}	×
271	auto func = forceQMOff ? resolveForceNoQM : resolve;	966!
272	pdns::ResolveTask task{qname, qtype, deadline, false, func, {}, {}, {}};	966✔
273	auto lock = s_taskQueue.lock();	966✔
274	bool inserted = lock->rateLimitSet.insert(now, task);	966✔
275	if (inserted) {	966✔
276	if (lock->queue.push(std::move(task))) {	412!
277	++s_resolve_tasks.pushed;	412✔
278	}	412✔
279	}	412✔
280	}	966✔
281
282	bool pushTryDoTTask(const DNSName& qname, uint16_t qtype, const ComboAddress& ipAddress, time_t deadline, const DNSName& nsname)
283	{	×
284	if (SyncRes::isUnsupported(qtype)) {	×
285	auto log = g_slog->withName("taskq")->withValues("name", Logging::Loggable(qname), "qtype", Logging::Loggable(QType(qtype).toString()));	×
286	log->error(Logr::Error, "Cannot push task", "qtype unsupported");	×
287	return false;	×
288	}	×
289
290	pdns::ResolveTask task{qname, qtype, deadline, false, tryDoT, ipAddress, nsname, {}};	×
291	bool pushed = s_taskQueue.lock()->queue.push(std::move(task));	×
292	if (pushed) {	×
293	++s_almost_expired_tasks.pushed;	×
294	}	×
295	return pushed;	×
296	}	×
297
298	uint64_t getTaskPushes()
299	{	168✔
300	return s_taskQueue.lock()->queue.getPushes();	168✔
301	}	168✔
302
303	uint64_t getTaskExpired()
304	{	172✔
305	return s_taskQueue.lock()->queue.getExpired();	172✔
306	}	172✔
307
308	uint64_t getTaskSize()
309	{	212✔
310	return s_taskQueue.lock()->queue.size();	212✔
311	}	212✔
312
313	void taskQueueClear()
314	{	600✔
315	auto lock = s_taskQueue.lock();	600✔
316	lock->queue.clear();	600✔
317	lock->rateLimitSet.clear();	600✔
318	}	600✔
319
320	pdns::ResolveTask taskQueuePop()
321	{	28✔
322	return s_taskQueue.lock()->queue.pop();	28✔
323	}	28✔
324
325	uint64_t getAlmostExpiredTasksPushed()
326	{	123✔
327	return s_almost_expired_tasks.pushed;	123✔
328	}	123✔
329
330	uint64_t getAlmostExpiredTasksRun()
331	{	123✔
332	return s_almost_expired_tasks.run;	123✔
333	}	123✔
334
335	uint64_t getAlmostExpiredTaskExceptions()
336	{	123✔
337	return s_almost_expired_tasks.exceptions;	123✔
338	}	123✔
339
340	uint64_t getResolveTasksPushed()
341	{	×
342	return s_almost_expired_tasks.pushed;	×
343	}	×
344
345	uint64_t getResolveTasksRun()
346	{	×
347	return s_almost_expired_tasks.run;	×
348	}	×
349
350	uint64_t getResolveTaskExceptions()
351	{	×
352	return s_almost_expired_tasks.exceptions;	×
353	}	×
354
355	bool taskQTypeIsSupported(QType qtype)
356	{	2,256✔
357	return !SyncRes::isUnsupported(qtype);	2,256✔
358	}	2,256✔

PowerDNS / pdns / 11163303031

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous