7298986676

Committed 22 Dec 2023 10:43AM UTC coverage: 57.676% (-0.008%) from 57.684%

Build # 7298986676

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13613 from fredmorcos/ws-auth-statbag-cleanup

Remove the `extern`ed `StatBag` from `ws-auth`

Run Details

31978 of 86792 branches covered (0.0%)

Branch coverage included in aggregate %.

765 of 904 new or added lines in 3 files covered. (84.62%)

57 existing lines in 13 files now uncovered.

107638 of 155277 relevant lines covered (69.32%)

3643353.85 hits per line

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

88.66

/pdns/test-distributor_hh.cc

#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
#endif

#define BOOST_TEST_NO_MAIN
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <unistd.h>
#include <boost/test/unit_test.hpp>
#include "distributor.hh"
#include "dnspacket.hh"
#include "namespaces.hh"

bool g_doGssTSIG = false;

BOOST_AUTO_TEST_SUITE(test_distributor_hh)

struct Question
{
  int q;
  DTime d_dt;
  DNSName qdomain;
  QType qtype;
  std::unique_ptr<DNSPacket> replyPacket()
  {
    return make_unique<DNSPacket>(false);
  }
  void cleanupGSS(int){}
};

struct Backend
{
  std::unique_ptr<DNSPacket> question(Question&)
  {
    return make_unique<DNSPacket>(true);
  }
};

static std::atomic<int> g_receivedAnswers;
static void report(std::unique_ptr<DNSPacket>& /* A */, int /* B */)
{
  g_receivedAnswers++;
}

BOOST_AUTO_TEST_CASE(test_distributor_basic) {
  ::arg().set("overload-queue-length","Maximum queuelength moving to packetcache only")="0";
  ::arg().set("max-queue-length","Maximum queuelength before considering situation lost")="5000";
  ::arg().set("queue-limit","Maximum number of milliseconds to queue a query")="1500";
  S.declare("servfail-packets","Number of times a server-failed packet was sent out");
  S.declare("timedout-packets", "timedout-packets");

  auto d=Distributor<DNSPacket, Question, Backend>::Create(2);

  int n;
  for(n=0; n < 100; ++n)  {
    Question q;
    q.d_dt.set();
    d->question(q, report);
  }
  sleep(1);
  BOOST_CHECK_EQUAL(n, g_receivedAnswers);
};

struct BackendSlow
{
  std::unique_ptr<DNSPacket> question(Question&)
  {
    sleep(1);
    return make_unique<DNSPacket>(true);
  }
};

static std::atomic<int> g_receivedAnswers1;
static void report1(std::unique_ptr<DNSPacket>& /* A */, int /* B */)
{
  g_receivedAnswers1++;
}

BOOST_AUTO_TEST_CASE(test_distributor_queue) {
  ::arg().set("overload-queue-length","Maximum queuelength moving to packetcache only")="0";
  ::arg().set("max-queue-length","Maximum queuelength before considering situation lost")="1000";
  ::arg().set("queue-limit","Maximum number of milliseconds to queue a query")="1500";
  S.declare("servfail-packets","Number of times a server-failed packet was sent out");
  S.declare("timedout-packets", "timedout-packets");

  auto d=Distributor<DNSPacket, Question, BackendSlow>::Create(2);

  BOOST_CHECK_EXCEPTION( {
    int n;
    // bound should be higher than max-queue-length
    for(n=0; n < 2000; ++n)  {
      Question q;
      q.d_dt.set();
      d->question(q, report1);
    }
    }, DistributorFatal, [](DistributorFatal) { return true; });
};

struct BackendDies
{
  BackendDies()
  {
    d_ourcount=s_count++;
  }
  ~BackendDies()
  {
  }
  std::unique_ptr<DNSPacket> question(Question& /* q */)
  {
    //  cout<<"Q: "<<q->qdomain<<endl;
    if(!d_ourcount && ++d_count == 10) {
      // cerr<<"Going.. down!"<<endl;
      throw runtime_error("kill");
    }
    return make_unique<DNSPacket>(true);
  }
  static std::atomic<int> s_count;
  int d_count{0};
  int d_ourcount;
};

std::atomic<int> BackendDies::s_count;

std::atomic<int> g_receivedAnswers2;

static void report2(std::unique_ptr<DNSPacket>& /* A */, int /* B */)
{
  g_receivedAnswers2++;
}


BOOST_AUTO_TEST_CASE(test_distributor_dies) {
  ::arg().set("overload-queue-length","Maximum queuelength moving to packetcache only")="0";
  ::arg().set("max-queue-length","Maximum queuelength before considering situation lost")="5000";
  ::arg().set("queue-limit","Maximum number of milliseconds to queue a query")="1500";
  S.declare("servfail-packets","Number of times a server-failed packet was sent out");
  S.declare("timedout-packets", "timedout-packets");

  auto d=Distributor<DNSPacket, Question, BackendDies>::Create(10);

  try {
    for(int n=0; n < 100; ++n)  {
      Question q;
      q.d_dt.set();
      q.qdomain=DNSName(std::to_string(n));
      q.qtype = QType(QType::A);
      d->question(q, report2);
    }

    sleep(1);
    cerr<<"Queued: "<<d->getQueueSize()<<endl;
    cerr<<"Received: "<<g_receivedAnswers2<<endl;
  }
  catch(std::exception& e) {
    cerr<<e.what()<<endl;
  }
  catch(PDNSException &pe) {
    cerr<<pe.reason<<endl;
  }
};



BOOST_AUTO_TEST_SUITE_END();

1	#ifndef BOOST_TEST_DYN_LINK
2	#define BOOST_TEST_DYN_LINK
3	#endif
4
5	#define BOOST_TEST_NO_MAIN
6	#ifdef HAVE_CONFIG_H
7	#include "config.h"
8	#endif
9	#include <stdlib.h>
10	#include <unistd.h>
11	#include <boost/test/unit_test.hpp>
12	#include "distributor.hh"
13	#include "dnspacket.hh"
14	#include "namespaces.hh"
15
16	bool g_doGssTSIG = false;
17
18	BOOST_AUTO_TEST_SUITE(test_distributor_hh)
19
20	struct Question
21	{
22	int q;
23	DTime d_dt;
24	DNSName qdomain;
25	QType qtype;
26	std::unique_ptr<DNSPacket> replyPacket()
27	{	×
28	return make_unique<DNSPacket>(false);	×
29	}	×
30	void cleanupGSS(int){}	×
31	};
32
33	struct Backend
34	{
35	std::unique_ptr<DNSPacket> question(Question&)
36	{	98✔
37	return make_unique<DNSPacket>(true);	98✔
38	}	98✔
39	};
40
41	static std::atomic<int> g_receivedAnswers;
42	static void report(std::unique_ptr<DNSPacket>& /* A /, int / B */)
43	{	100✔
44	g_receivedAnswers++;	100✔
45	}	100✔
46
47	BOOST_AUTO_TEST_CASE(test_distributor_basic) {	1✔
48	::arg().set("overload-queue-length","Maximum queuelength moving to packetcache only")="0";	1✔
49	::arg().set("max-queue-length","Maximum queuelength before considering situation lost")="5000";	1✔
50	::arg().set("queue-limit","Maximum number of milliseconds to queue a query")="1500";	1✔
51	S.declare("servfail-packets","Number of times a server-failed packet was sent out");	1✔
52	S.declare("timedout-packets", "timedout-packets");	1✔
53
54	auto d=Distributor<DNSPacket, Question, Backend>::Create(2);	1✔
55
56	int n;	1✔
57	for(n=0; n < 100; ++n) {	101✔
58	Question q;	100✔
59	q.d_dt.set();	100✔
60	d->question(q, report);	100✔
61	}	100✔
62	sleep(1);	1✔
63	BOOST_CHECK_EQUAL(n, g_receivedAnswers);	1✔
64	};	1✔
65
66	struct BackendSlow
67	{
68	std::unique_ptr<DNSPacket> question(Question&)
69	{	2✔
70	sleep(1);	2✔
71	return make_unique<DNSPacket>(true);	2✔
72	}	2✔
73	};
74
75	static std::atomic<int> g_receivedAnswers1;
76	static void report1(std::unique_ptr<DNSPacket>& /* A /, int / B */)
UNCOV 77	{	×
UNCOV 78	g_receivedAnswers1++;	×
UNCOV 79	}	×
80
81	BOOST_AUTO_TEST_CASE(test_distributor_queue) {	1✔
82	::arg().set("overload-queue-length","Maximum queuelength moving to packetcache only")="0";	1✔
83	::arg().set("max-queue-length","Maximum queuelength before considering situation lost")="1000";	1✔
84	::arg().set("queue-limit","Maximum number of milliseconds to queue a query")="1500";	1✔
85	S.declare("servfail-packets","Number of times a server-failed packet was sent out");	1✔
86	S.declare("timedout-packets", "timedout-packets");	1✔
87
88	auto d=Distributor<DNSPacket, Question, BackendSlow>::Create(2);	1✔
89
90	BOOST_CHECK_EXCEPTION( {	1✔
91	int n;	1✔
92	// bound should be higher than max-queue-length
93	for(n=0; n < 2000; ++n) {	1✔
94	Question q;	1✔
95	q.d_dt.set();	1✔
96	d->question(q, report1);	1✔
97	}	1✔
98	}, DistributorFatal, [](DistributorFatal) { return true; });	1✔
99	};	1✔
100
101	struct BackendDies
102	{
103	BackendDies()
104	{	11✔
105	d_ourcount=s_count++;	11✔
106	}	11✔
107	~BackendDies()
108	{	1✔
109	}	1✔
110	std::unique_ptr<DNSPacket> question(Question& /* q */)
111	{	101✔
112	// cout<<"Q: "<<q->qdomain<<endl;
113	if(!d_ourcount && ++d_count == 10) {	101✔
114	// cerr<<"Going.. down!"<<endl;
115	throw runtime_error("kill");	1✔
116	}	1✔
117	return make_unique<DNSPacket>(true);	100✔
118	}	101✔
119	static std::atomic<int> s_count;
120	int d_count{0};
121	int d_ourcount;
122	};
123
124	std::atomic<int> BackendDies::s_count;
125
126	std::atomic<int> g_receivedAnswers2;
127
128	static void report2(std::unique_ptr<DNSPacket>& /* A /, int / B */)
129	{	100✔
130	g_receivedAnswers2++;	100✔
131	}	100✔
132
133
134	BOOST_AUTO_TEST_CASE(test_distributor_dies) {	1✔
135	::arg().set("overload-queue-length","Maximum queuelength moving to packetcache only")="0";	1✔
136	::arg().set("max-queue-length","Maximum queuelength before considering situation lost")="5000";	1✔
137	::arg().set("queue-limit","Maximum number of milliseconds to queue a query")="1500";	1✔
138	S.declare("servfail-packets","Number of times a server-failed packet was sent out");	1✔
139	S.declare("timedout-packets", "timedout-packets");	1✔
140
141	auto d=Distributor<DNSPacket, Question, BackendDies>::Create(10);	1✔
142
143	try {	1✔
144	for(int n=0; n < 100; ++n) {	101✔
145	Question q;	100✔
146	q.d_dt.set();	100✔
147	q.qdomain=DNSName(std::to_string(n));	100✔
148	q.qtype = QType(QType::A);	100✔
149	d->question(q, report2);	100✔
150	}	100✔
151
152	sleep(1);	1✔
153	cerr<<"Queued: "<<d->getQueueSize()<<endl;	1✔
154	cerr<<"Received: "<<g_receivedAnswers2<<endl;	1✔
155	}	1✔
156	catch(std::exception& e) {	1✔
157	cerr<<e.what()<<endl;	×
158	}	×
159	catch(PDNSException &pe) {	1✔
160	cerr<<pe.reason<<endl;	×
161	}	×
162	};	1✔
163
164
165
166	BOOST_AUTO_TEST_SUITE_END();

PowerDNS / pdns / 7298986676

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