regression-tests.dnsdist/test_TeeAction.py

   1 #!/usr/bin/env python
   2 import base64
   3 import Queue
   4 import threading
   5 import clientsubnetoption
   6 import dns
   7 from dnsdisttests import DNSDistTest
   8
   9 class TestTeeAction(DNSDistTest):
  10
  11     _consoleKey = DNSDistTest.generateConsoleKey()
  12     _consoleKeyB64 = base64.b64encode(_consoleKey)
  13     _teeServerPort = 5390
  14     _toTeeQueue = Queue.Queue()
  15     _fromTeeQueue = Queue.Queue()
  16     _config_template = """
  17     setKey("%s")
  18     controlSocket("127.0.0.1:%s")
  19     newServer{address="127.0.0.1:%d"}
  20     addAction(QTypeRule(dnsdist.A), TeeAction("127.0.0.1:%d", true))
  21     addAction(QTypeRule(dnsdist.AAAA), TeeAction("127.0.0.1:%d", false))
  22     """
  23     _config_params = ['_consoleKeyB64', '_consolePort', '_testServerPort', '_teeServerPort', '_teeServerPort']
  24     @classmethod
  25     def startResponders(cls):
  26         print("Launching responders..")
  27
  28         cls._UDPResponder = threading.Thread(name='UDP Responder', target=cls.UDPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue])
  29         cls._UDPResponder.setDaemon(True)
  30         cls._UDPResponder.start()
  31
  32         cls._TCPResponder = threading.Thread(name='TCP Responder', target=cls.TCPResponder, args=[cls._testServerPort, cls._toResponderQueue, cls._fromResponderQueue, False, True])
  33         cls._TCPResponder.setDaemon(True)
  34         cls._TCPResponder.start()
  35
  36         cls._TeeResponder = threading.Thread(name='Tee Responder', target=cls.UDPResponder, args=[cls._teeServerPort, cls._toTeeQueue, cls._fromTeeQueue])
  37         cls._TeeResponder.setDaemon(True)
  38         cls._TeeResponder.start()
  39
  40     def testTeeWithECS(self):
  41         """
  42         TeeAction: ECS
  43         """
  44         name = 'ecs.tee.tests.powerdns.com.'
  45         query = dns.message.make_query(name, 'A', 'IN')
  46         response = dns.message.make_response(query)
  47
  48         rrset = dns.rrset.from_text(name,
  49                                     3600,
  50                                     dns.rdataclass.IN,
  51                                     dns.rdatatype.A,
  52                                     '192.0.2.1')
  53         response.answer.append(rrset)
  54
  55         numberOfQueries = 10
  56         for _ in range(numberOfQueries):
  57             # push the response to the Tee server
  58             self._toTeeQueue.put(response, True, 2.0)
  59
  60             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
  61             self.assertTrue(receivedQuery)
  62             self.assertTrue(receivedResponse)
  63             receivedQuery.id = query.id
  64             self.assertEquals(query, receivedQuery)
  65             self.assertEquals(response, receivedResponse)
  66
  67             # retrieve the query from the Tee server
  68             teedQuery = self._fromTeeQueue.get(True, 2.0)
  69             ecso = clientsubnetoption.ClientSubnetOption('127.0.0.1', 24)
  70             expectedQuery = dns.message.make_query(name, 'A', 'IN', use_edns=True, options=[ecso], payload=512)
  71             expectedQuery.id = query.id
  72             self.checkQueryEDNSWithECS(expectedQuery, teedQuery)
  73
  74         # check the TeeAction stats
  75         stats = self.sendConsoleCommand("getAction(0):printStats()")
  76         self.assertEquals(stats, """refuseds\t0
  77 nxdomains\t0
  78 noerrors\t%d
  79 servfails\t0
  80 recv-errors\t0
  81 tcp-drops\t0
  82 responses\t%d
  83 other-rcode\t0
  84 send-errors\t0
  85 queries\t%d
  86 """ % (numberOfQueries, numberOfQueries, numberOfQueries))
  87
  88     def testTeeWithoutECS(self):
  89         """
  90         TeeAction: No ECS
  91         """
  92         name = 'noecs.tee.tests.powerdns.com.'
  93         query = dns.message.make_query(name, 'AAAA', 'IN')
  94         response = dns.message.make_response(query)
  95
  96         rrset = dns.rrset.from_text(name,
  97                                     3600,
  98                                     dns.rdataclass.IN,
  99                                     dns.rdatatype.AAAA,
 100                                     '2001:DB8::1')
 101         response.answer.append(rrset)
 102
 103         numberOfQueries = 10
 104         for _ in range(numberOfQueries):
 105             # push the response to the Tee server
 106             self._toTeeQueue.put(response, True, 2.0)
 107
 108             (receivedQuery, receivedResponse) = self.sendUDPQuery(query, response)
 109             self.assertTrue(receivedQuery)
 110             self.assertTrue(receivedResponse)
 111             receivedQuery.id = query.id
 112             self.assertEquals(query, receivedQuery)
 113             self.assertEquals(response, receivedResponse)
 114
 115             # retrieve the query from the Tee server
 116             teedQuery = self._fromTeeQueue.get(True, 2.0)
 117             ecso = clientsubnetoption.ClientSubnetOption('127.0.0.1', 24)
 118             expectedQuery = dns.message.make_query(name, 'AAAA', 'IN', use_edns=True, options=[ecso], payload=512)
 119             expectedQuery.id = query.id
 120             self.checkMessageNoEDNS(expectedQuery, teedQuery)
 121
 122         # check the TeeAction stats
 123         stats = self.sendConsoleCommand("getAction(0):printStats()")
 124         self.assertEquals(stats, """refuseds\t0
 125 nxdomains\t0
 126 noerrors\t%d
 127 servfails\t0
 128 recv-errors\t0
 129 tcp-drops\t0
 130 responses\t%d
 131 other-rcode\t0
 132 send-errors\t0
 133 queries\t%d
 134 """ % (numberOfQueries, numberOfQueries, numberOfQueries))