regression-tests.dnsdist/test_Carbon.py

   1 #!/usr/bin/env python
   2 import threading
   3 import socket
   4 import sys
   5 import time
   6 from dnsdisttests import DNSDistTest, Queue, pickAvailablePort
   7
   8 class TestCarbon(DNSDistTest):
   9
  10     _carbonServer1Port = pickAvailablePort()
  11     _carbonServer1Name = "carbonname1"
  12     _carbonServer2Port = pickAvailablePort()
  13     _carbonServer2Name = "carbonname2"
  14     _carbonQueue1 = Queue()
  15     _carbonQueue2 = Queue()
  16     _carbonInterval = 2
  17     _carbonCounters = {}
  18     _config_params = ['_carbonServer1Port', '_carbonServer1Name', '_carbonInterval',
  19                       '_carbonServer2Port', '_carbonServer2Name', '_carbonInterval']
  20     _config_template = """
  21     s = newServer{address="127.0.0.1:5353"}
  22     s:setDown()
  23     s = newServer{address="127.0.0.1:5354"}
  24     s:setUp()
  25     s = newServer{address="127.0.0.1:5355"}
  26     s:setUp()
  27     carbonServer("127.0.0.1:%s", "%s", %s)
  28     carbonServer("127.0.0.1:%s", "%s", %s)
  29     """
  30
  31     @classmethod
  32     def CarbonResponder(cls, port):
  33         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  34         sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
  35         try:
  36             sock.bind(("127.0.0.1", port))
  37         except socket.error as e:
  38             print("Error binding in the Carbon responder: %s" % str(e))
  39             sys.exit(1)
  40
  41         sock.listen(100)
  42         while True:
  43             (conn, _) = sock.accept()
  44             conn.settimeout(2.0)
  45             lines = b''
  46             while True:
  47                 data = conn.recv(4096)
  48                 if not data:
  49                     break
  50                 lines += data
  51
  52             if port == cls._carbonServer1Port:
  53                 cls._carbonQueue1.put(lines, True, timeout=2.0)
  54             else:
  55                 cls._carbonQueue2.put(lines, True, timeout=2.0)
  56             if threading.current_thread().name in cls._carbonCounters:
  57                 cls._carbonCounters[threading.current_thread().name] += 1
  58             else:
  59                 cls._carbonCounters[threading.current_thread().name] = 1
  60
  61             conn.close()
  62         sock.close()
  63
  64     @classmethod
  65     def startResponders(cls):
  66         cls._CarbonResponder1 = threading.Thread(name='Carbon Responder 1', target=cls.CarbonResponder, args=[cls._carbonServer1Port])
  67         cls._CarbonResponder1.daemon = True
  68         cls._CarbonResponder1.start()
  69
  70         cls._CarbonResponder2 = threading.Thread(name='Carbon Responder 2', target=cls.CarbonResponder, args=[cls._carbonServer2Port])
  71         cls._CarbonResponder2.daemon = True
  72         cls._CarbonResponder2.start()
  73
  74     def isfloat(self, num):
  75         try:
  76             float(num)
  77             return True
  78         except ValueError:
  79             return False
  80
  81     def testCarbon(self):
  82         """
  83         Carbon: send data to 2 carbon servers
  84         """
  85         # wait for the carbon data to be sent
  86         time.sleep(self._carbonInterval + 1)
  87
  88         # check if the servers have received our data
  89         # we will block for a short while if the data is not already there,
  90         # and an exception will be raised after the timeout
  91         # first server
  92         data1 = self._carbonQueue1.get(block=True, timeout=2.0)
  93         # second server
  94         data2 = self._carbonQueue2.get(block=True, timeout=2.0)
  95         after = time.time()
  96
  97         self.assertTrue(data1)
  98         self.assertTrue(len(data1.splitlines()) > 1)
  99         expectedStart = b"dnsdist.%s.main." % self._carbonServer1Name.encode('UTF-8')
 100         for line in data1.splitlines():
 101             self.assertTrue(line.startswith(expectedStart))
 102             parts = line.split(b' ')
 103             self.assertEqual(len(parts), 3)
 104             self.assertTrue(self.isfloat(parts[1]))
 105             self.assertTrue(parts[2].isdigit())
 106             self.assertTrue(int(parts[2]) <= int(after))
 107
 108         self.assertTrue(data2)
 109         self.assertTrue(len(data2.splitlines()) > 1)
 110         expectedStart = b"dnsdist.%s.main." % self._carbonServer2Name.encode('UTF-8')
 111         for line in data2.splitlines():
 112             self.assertTrue(line.startswith(expectedStart))
 113             parts = line.split(b' ')
 114             self.assertEqual(len(parts), 3)
 115             self.assertTrue(self.isfloat(parts[1]))
 116             self.assertTrue(parts[2].isdigit())
 117             self.assertTrue(int(parts[2]) <= int(after))
 118
 119         # make sure every carbon server has received at least one connection
 120         for key in self._carbonCounters:
 121             value = self._carbonCounters[key]
 122             self.assertTrue(value >= 1)
 123
 124     def testCarbonServerUp(self):
 125         """
 126         Carbon: set up 2 carbon servers
 127         """
 128         # wait for the carbon data to be sent
 129         time.sleep(self._carbonInterval + 1)
 130
 131         # check if the servers have received our data
 132         # we will block for a short while if the data is not already there,
 133         # and an exception will be raised after the timeout
 134         # first server
 135         data1 = self._carbonQueue1.get(block=True, timeout=2.0)
 136         # second server
 137         data2 = self._carbonQueue2.get(block=True, timeout=2.0)
 138         after = time.time()
 139
 140         # check the first carbon server got both servers and
 141         # servers-up metrics and that they are the same as
 142         # configured in the class definition
 143         self.assertTrue(data1)
 144         self.assertTrue(len(data1.splitlines()) > 1)
 145         expectedStart = b"dnsdist.%s.main.pools._default_.servers" % self._carbonServer1Name.encode('UTF-8')
 146         for line in data1.splitlines():
 147             if expectedStart in line:
 148                 parts = line.split(b' ')
 149                 if b'servers-up' in line:
 150                     self.assertEqual(len(parts), 3)
 151                     self.assertTrue(parts[1].isdigit())
 152                     self.assertEqual(int(parts[1]), 2)
 153                     self.assertTrue(parts[2].isdigit())
 154                     self.assertTrue(int(parts[2]) <= int(after))
 155                 else:
 156                     self.assertEqual(len(parts), 3)
 157                     self.assertTrue(parts[1].isdigit())
 158                     self.assertEqual(int(parts[1]), 3)
 159                     self.assertTrue(parts[2].isdigit())
 160                     self.assertTrue(int(parts[2]) <= int(after))
 161
 162         # check the second carbon server got both servers and
 163         # servers-up metrics and that they are the same as
 164         # configured in the class definition and the same as
 165         # the first carbon server
 166         self.assertTrue(data2)
 167         self.assertTrue(len(data2.splitlines()) > 1)
 168         expectedStart = b"dnsdist.%s.main.pools._default_.servers" % self._carbonServer2Name.encode('UTF-8')
 169         for line in data2.splitlines():
 170             if expectedStart in line:
 171                 parts = line.split(b' ')
 172                 if b'servers-up' in line:
 173                     self.assertEqual(len(parts), 3)
 174                     self.assertTrue(parts[1].isdigit())
 175                     self.assertEqual(int(parts[1]), 2)
 176                     self.assertTrue(parts[2].isdigit())
 177                     self.assertTrue(int(parts[2]) <= int(after))
 178                 else:
 179                     self.assertEqual(len(parts), 3)
 180                     self.assertTrue(parts[1].isdigit())
 181                     self.assertEqual(int(parts[1]), 3)
 182                     self.assertTrue(parts[2].isdigit())
 183                     self.assertTrue(int(parts[2]) <= int(after))