regression-tests.dnsdist/test_TCPLimits.py

   1 #!/usr/bin/env python
   2 import struct
   3 import time
   4 import dns
   5 from dnsdisttests import DNSDistTest, range
   6
   7 class TestTCPLimits(DNSDistTest):
   8
   9     # this test suite uses a different responder port
  10     # because it uses a different health check configuration
  11     _testServerPort = 5395
  12     _answerUnexpected = True
  13
  14     _tcpIdleTimeout = 2
  15     _maxTCPQueriesPerConn = 5
  16     _maxTCPConnsPerClient = 3
  17     _maxTCPConnDuration = 5
  18     _config_template = """
  19     newServer{address="127.0.0.1:%s"}
  20     setTCPRecvTimeout(%s)
  21     setMaxTCPQueriesPerConnection(%s)
  22     setMaxTCPConnectionsPerClient(%s)
  23     setMaxTCPConnectionDuration(%s)
  24     """
  25     _config_params = ['_testServerPort', '_tcpIdleTimeout', '_maxTCPQueriesPerConn', '_maxTCPConnsPerClient', '_maxTCPConnDuration']
  26
  27     def testTCPQueriesPerConn(self):
  28         """
  29         TCP Limits: Maximum number of queries
  30         """
  31         name = 'maxqueriesperconn.tcp.tests.powerdns.com.'
  32         query = dns.message.make_query(name, 'A', 'IN')
  33         conn = self.openTCPConnection()
  34
  35         count = 0
  36         for idx in range(self._maxTCPQueriesPerConn):
  37             try:
  38                 self.sendTCPQueryOverConnection(conn, query)
  39                 response = self.recvTCPResponseOverConnection(conn)
  40                 self.assertTrue(response)
  41                 count = count + 1
  42             except:
  43                 pass
  44
  45         # this one should fail
  46         failed = False
  47         try:
  48             self.sendTCPQueryOverConnection(conn, query)
  49             response = self.recvTCPResponseOverConnection(conn)
  50             self.assertFalse(response)
  51             if not response:
  52                 failed = True
  53             else:
  54                 count = count + 1
  55         except:
  56             failed = True
  57
  58         conn.close()
  59         self.assertTrue(failed)
  60         self.assertEqual(count, self._maxTCPQueriesPerConn)
  61
  62     def testTCPConnsPerClient(self):
  63         """
  64         TCP Limits: Maximum number of conns per client
  65         """
  66         name = 'maxconnsperclient.tcp.tests.powerdns.com.'
  67         query = dns.message.make_query(name, 'A', 'IN')
  68         conns = []
  69
  70         for idx in range(self._maxTCPConnsPerClient + 1):
  71             conns.append(self.openTCPConnection())
  72
  73         count = 0
  74         failed = 0
  75         for conn in conns:
  76             try:
  77                 self.sendTCPQueryOverConnection(conn, query)
  78                 response = self.recvTCPResponseOverConnection(conn)
  79                 if response:
  80                     count = count + 1
  81                 else:
  82                     failed = failed + 1
  83             except:
  84                 failed = failed + 1
  85
  86         for conn in conns:
  87             conn.close()
  88
  89         self.assertEqual(count, self._maxTCPConnsPerClient)
  90         self.assertEqual(failed, 1)
  91
  92     def testTCPDuration(self):
  93         """
  94         TCP Limits: Maximum duration
  95         """
  96         name = 'duration.tcp.tests.powerdns.com.'
  97
  98         start = time.time()
  99         conn = self.openTCPConnection()
 100         # immediately send the maximum size
 101         conn.send(struct.pack("!H", 65535))
 102
 103         count = 0
 104         while count < (self._maxTCPConnDuration * 2):
 105             try:
 106                 # sleeping for only one second keeps us below the
 107                 # idle timeout (setTCPRecvTimeout())
 108                 time.sleep(1)
 109                 conn.send('A')
 110                 count = count + 1
 111             except:
 112                 break
 113
 114         end = time.time()
 115
 116         self.assertAlmostEquals(count, self._maxTCPConnDuration, delta=2)
 117         self.assertAlmostEquals(end - start, self._maxTCPConnDuration, delta=2)
 118
 119         conn.close()