test_utils.py 16.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
"""
Utilities and mock modules for unittests of statistics modules

"""
import os
import io
import time
import sys
import threading
import tempfile
Naoki Kambe's avatar
Naoki Kambe committed
11
import json
12
import signal
13
14

import msgq
15
import isc.config.cfgmgr
16
17
18
import stats
import stats_httpd

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class SignalHandler():
    """A signal handler class for deadlock in unittest"""
    def __init__(self, fail_handler, timeout=20):
        """sets a schedule in SIGARM for invoking the handler via
        unittest.TestCase after timeout seconds (default is 20)"""
        self.fail_handler = fail_handler
        self.orig_handler = signal.signal(signal.SIGALRM, self.sig_handler)
        signal.alarm(timeout)

    def reset(self):
        """resets the schedule in SIGALRM"""
        signal.alarm(0)
        signal.signal(signal.SIGALRM, self.orig_handler)

    def sig_handler(self, signal, frame):
        """envokes unittest.TestCase.fail as a signal handler"""
        self.fail_handler("A deadlock might be detected")

Naoki Kambe's avatar
Naoki Kambe committed
37
38
def send_command(command_name, module_name, params=None, session=None, nonblock=False, timeout=None):
    if session is not None:
39
        cc_session = session
Naoki Kambe's avatar
Naoki Kambe committed
40
41
42
43
44
    else:
        cc_session = isc.cc.Session()
    if timeout is not None:
        orig_timeout = cc_session.get_timeout()
        cc_session.set_timeout(timeout * 1000)
45
46
47
48
49
50
51
52
53
    command = isc.config.ccsession.create_command(command_name, params)
    seq = cc_session.group_sendmsg(command, module_name)
    try:
        (answer, env) = cc_session.group_recvmsg(nonblock, seq)
        if answer:
            return isc.config.ccsession.parse_answer(answer)
    except isc.cc.SessionTimeout:
        pass
    finally:
Naoki Kambe's avatar
Naoki Kambe committed
54
        if timeout is not None:
55
            cc_session.set_timeout(orig_timeout)
Naoki Kambe's avatar
Naoki Kambe committed
56
57
        if session is None:
            cc_session.close()
58

Naoki Kambe's avatar
Naoki Kambe committed
59
60
def send_shutdown(module_name, **kwargs):
    return send_command("shutdown", module_name, **kwargs)
61
62

class ThreadingServerManager:
Naoki Kambe's avatar
Naoki Kambe committed
63
    def __init__(self, server, *args, **kwargs):
64
        self.server = server(*args, **kwargs)
Naoki Kambe's avatar
Naoki Kambe committed
65
        self.server_name = server.__name__
66
        self.server._thread = threading.Thread(
Naoki Kambe's avatar
Naoki Kambe committed
67
            name=self.server_name, target=self.server.run)
68
        self.server._thread.daemon = True
69

70
71
72
    def run(self):
        self.server._thread.start()
        self.server._started.wait()
73
        self.server._started.clear()
74

75
76
77
78
79
80
81
82
    def shutdown(self, blocking=False):
        """Shut down the server by calling its own shutdown() method.
           Then wait for its thread to finish. If blocking is True,
           the thread.join() blocks until the thread finishes. If not,
           it uses a zero timeout. The latter is necessary in a number
           of existing tests. We should redo this part (we should not
           even need threads in most, if not all, of these threads, see
           ticket #1668)"""
83
        self.server.shutdown()
84
85
86
87
        if blocking:
            self.server._thread.join()
        else:
            self.server._thread.join(0) # timeout is 0
88

Naoki Kambe's avatar
Naoki Kambe committed
89
90
91
92
93
94
95
96
def do_nothing(*args, **kwargs): pass

class dummy_sys:
    """Dummy for sys"""
    class dummy_io:
        write = do_nothing
    stdout = stderr = dummy_io()

97
class MockMsgq:
98
    def __init__(self):
99
        self._started = threading.Event()
Naoki Kambe's avatar
Naoki Kambe committed
100
101
102
103
        # suppress output to stdout and stderr
        msgq.sys = dummy_sys()
        msgq.print = do_nothing
        self.msgq = msgq.MsgQ(verbose=False)
104
105
106
107
108
109
        result = self.msgq.setup()
        if result:
            sys.exit("Error on Msgq startup: %s" % result)

    def run(self):
        self._started.set()
110
        self.msgq.run()
111
112

    def shutdown(self):
113
        self.msgq.shutdown()
114
115

class MockCfgmgr:
116
    def __init__(self):
117
118
        self._started = threading.Event()
        self.cfgmgr = isc.config.cfgmgr.ConfigManager(
119
            os.environ['CONFIG_TESTDATA_PATH'], "b10-config.db")
120
121
122
123
        self.cfgmgr.read_config()

    def run(self):
        self._started.set()
Naoki Kambe's avatar
Naoki Kambe committed
124
125
126
127
        try:
            self.cfgmgr.run()
        except Exception:
            pass
128
129
130

    def shutdown(self):
        self.cfgmgr.running = False
131

132
133
134
135
136
137
class MockBoss:
    spec_str = """\
{
  "module_spec": {
    "module_name": "Boss",
    "module_description": "Mock Master process",
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
    "config_data": [
      {
        "item_name": "components",
        "item_type": "named_set",
        "item_optional": false,
        "item_default": {
          "b10-stats": { "address": "Stats", "kind": "dispensable" },
          "b10-cmdctl": { "special": "cmdctl", "kind": "needed" }
        },
        "named_set_item_spec": {
          "item_name": "component",
          "item_type": "map",
          "item_optional": false,
          "item_default": { },
          "map_item_spec": [
            {
              "item_name": "special",
              "item_optional": true,
              "item_type": "string"
            },
            {
              "item_name": "process",
              "item_optional": true,
              "item_type": "string"
            },
            {
              "item_name": "kind",
              "item_optional": false,
              "item_type": "string",
              "item_default": "dispensable"
            },
            {
              "item_name": "address",
              "item_optional": true,
              "item_type": "string"
            },
            {
              "item_name": "params",
              "item_optional": true,
              "item_type": "list",
              "list_item_spec": {
                "item_name": "param",
                "item_optional": false,
                "item_type": "string",
                "item_default": ""
              }
            },
            {
              "item_name": "priority",
              "item_optional": true,
              "item_type": "integer"
            }
          ]
        }
      }
    ],
194
    "commands": [
195
196
197
198
199
200
201
202
203
204
      {
        "command_name": "shutdown",
        "command_description": "Shut down BIND 10",
        "command_args": []
      },
      {
        "command_name": "ping",
        "command_description": "Ping the boss process",
        "command_args": []
      },
205
206
207
208
      {
        "command_name": "show_processes",
        "command_description": "List the running BIND 10 processes",
        "command_args": []
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
      }
    ],
    "statistics": [
      {
        "item_name": "boot_time",
        "item_type": "string",
        "item_optional": false,
        "item_default": "1970-01-01T00:00:00Z",
        "item_title": "Boot time",
        "item_description": "A date time when bind10 process starts initially",
        "item_format": "date-time"
      }
    ]
  }
}
"""
    _BASETIME = (2011, 6, 22, 8, 14, 8, 2, 173, 0)

227
    def __init__(self):
228
229
230
231
232
233
234
235
236
237
238
        self._started = threading.Event()
        self.running = False
        self.spec_file = io.StringIO(self.spec_str)
        # create ModuleCCSession object
        self.mccs = isc.config.ModuleCCSession(
            self.spec_file,
            self.config_handler,
            self.command_handler)
        self.spec_file.close()
        self.cc_session = self.mccs._session
        self.got_command_name = ''
239
240
        self.pid_list = [[ 9999, "b10-auth", "Auth" ],
                         [ 9998, "b10-auth-2", "Auth" ]]
241
242
243
        self.statistics_data = {
            'boot_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', self._BASETIME)
            }
244
245
246
247
248

    def run(self):
        self.mccs.start()
        self.running = True
        self._started.set()
Naoki Kambe's avatar
Naoki Kambe committed
249
250
251
252
253
        try:
            while self.running:
                self.mccs.check_command(False)
        except Exception:
            pass
254
255
256
257
258
259
260
261

    def shutdown(self):
        self.running = False

    def config_handler(self, new_config):
        return isc.config.create_answer(0)

    def command_handler(self, command, *args, **kwargs):
Naoki Kambe's avatar
Naoki Kambe committed
262
        self._started.set()
263
        self.got_command_name = command
264
        sdata = self.statistics_data
265
        if command == 'getstats':
266
            return isc.config.create_answer(0, sdata)
267
268
269
        elif command == 'show_processes':
            # Return dummy pids
            return isc.config.create_answer(
270
                0, self.pid_list)
271
272
273
274
275
276
277
278
279
        return isc.config.create_answer(1, "Unknown Command")

class MockAuth:
    spec_str = """\
{
  "module_spec": {
    "module_name": "Auth",
    "module_description": "Mock Authoritative service",
    "config_data": [],
280
    "commands": [],
281
282
283
284
285
286
    "statistics": [
      {
        "item_name": "queries.tcp",
        "item_type": "integer",
        "item_optional": false,
        "item_default": 0,
287
        "item_title": "Queries TCP",
288
289
290
291
292
293
294
295
296
        "item_description": "A number of total query counts which all auth servers receive over TCP since they started initially"
      },
      {
        "item_name": "queries.udp",
        "item_type": "integer",
        "item_optional": false,
        "item_default": 0,
        "item_title": "Queries UDP",
        "item_description": "A number of total query counts which all auth servers receive over UDP since they started initially"
297
298
      },
      {
299
        "item_name": "queries.perzone",
300
301
        "item_type": "list",
        "item_optional": false,
302
303
304
305
306
307
308
309
310
311
312
313
        "item_default": [
          {
            "zonename" : "test1.example",
            "queries.udp" : 1,
            "queries.tcp" : 2
          },
          {
            "zonename" : "test2.example",
            "queries.udp" : 3,
            "queries.tcp" : 4
          }
        ],
314
315
316
        "item_title": "Queries per zone",
        "item_description": "Queries per zone",
        "list_item_spec": {
317
          "item_name": "zones",
318
319
320
321
322
323
324
325
          "item_type": "map",
          "item_optional": false,
          "item_default": {},
          "map_item_spec": [
            {
              "item_name": "zonename",
              "item_type": "string",
              "item_optional": false,
Naoki Kambe's avatar
Naoki Kambe committed
326
327
328
              "item_default": "",
              "item_title": "Zonename",
              "item_description": "Zonename"
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
            },
            {
              "item_name": "queries.udp",
              "item_type": "integer",
              "item_optional": false,
              "item_default": 0,
              "item_title": "Queries UDP per zone",
              "item_description": "A number of UDP query counts per zone"
            },
            {
              "item_name": "queries.tcp",
              "item_type": "integer",
              "item_optional": false,
              "item_default": 0,
              "item_title": "Queries TCP per zone",
              "item_description": "A number of TCP query counts per zone"
            }
          ]
        }
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
      },
      {
        "item_name": "nds_queries.perzone",
        "item_type": "named_set",
        "item_optional": false,
        "item_default": {
          "test10.example" : {
            "queries.udp" : 1,
            "queries.tcp" : 2
          },
          "test20.example" : {
            "queries.udp" : 3,
            "queries.tcp" : 4
          }
        },
        "item_title": "Queries per zone",
        "item_description": "Queries per zone",
        "named_set_item_spec": {
          "item_name": "zonename",
          "item_type": "map",
          "item_optional": false,
          "item_default": {},
          "item_title": "Zonename",
          "item_description": "Zonename",
          "map_item_spec": [
            {
              "item_name": "queries.udp",
              "item_type": "integer",
              "item_optional": false,
              "item_default": 0,
              "item_title": "Queries UDP per zone",
              "item_description": "A number of UDP query counts per zone"
            },
            {
              "item_name": "queries.tcp",
              "item_type": "integer",
              "item_optional": false,
              "item_default": 0,
              "item_title": "Queries TCP per zone",
              "item_description": "A number of TCP query counts per zone"
            }
          ]
        }
391
392
393
394
395
      }
    ]
  }
}
"""
396
    def __init__(self):
397
398
399
400
401
402
403
404
405
406
407
408
409
        self._started = threading.Event()
        self.running = False
        self.spec_file = io.StringIO(self.spec_str)
        # create ModuleCCSession object
        self.mccs = isc.config.ModuleCCSession(
            self.spec_file,
            self.config_handler,
            self.command_handler)
        self.spec_file.close()
        self.cc_session = self.mccs._session
        self.got_command_name = ''
        self.queries_tcp = 3
        self.queries_udp = 2
410
        self.queries_per_zone = [{
411
                'zonename': 'test1.example',
412
413
414
                'queries.tcp': 5,
                'queries.udp': 4
                }]
415
416
417
418
419
420
        self.nds_queries_per_zone = {
            'test10.example': {
                'queries.tcp': 5,
                'queries.udp': 4
                }
            }
421
422
423
424
425

    def run(self):
        self.mccs.start()
        self.running = True
        self._started.set()
Naoki Kambe's avatar
Naoki Kambe committed
426
427
428
429
430
        try:
            while self.running:
                self.mccs.check_command(False)
        except Exception:
            pass
431
432
433
434
435
436
437
438
439

    def shutdown(self):
        self.running = False

    def config_handler(self, new_config):
        return isc.config.create_answer(0)

    def command_handler(self, command, *args, **kwargs):
        self.got_command_name = command
440
        sdata = { 'queries.tcp': self.queries_tcp,
Mukund Sivaraman's avatar
Mukund Sivaraman committed
441
                  'queries.udp': self.queries_udp,
442
                  'queries.perzone' : self.queries_per_zone,
443
444
445
446
447
448
449
450
451
452
453
454
                  'nds_queries.perzone' : {
                    'test10.example': {
                    'queries.tcp': \
                      isc.cc.data.find(
                        self.nds_queries_per_zone,
                        'test10.example/queries.tcp')
                    }
                  },
                  'nds_queries.perzone/test10.example/queries.udp' :
                      isc.cc.data.find(self.nds_queries_per_zone,
                                       'test10.example/queries.udp')
                }
455
        if command == 'getstats':
456
            return isc.config.create_answer(0, sdata)
457
458
459
        return isc.config.create_answer(1, "Unknown Command")

class MyStats(stats.Stats):
460
    def __init__(self):
461
        self._started = threading.Event()
462
        stats.Stats.__init__(self)
463
464
465

    def run(self):
        self._started.set()
Naoki Kambe's avatar
Naoki Kambe committed
466
467
468
        try:
            self.start()
        except Exception:
469
            pass
470
471

    def shutdown(self):
Naoki Kambe's avatar
Naoki Kambe committed
472
        self.command_shutdown()
473
474

class MyStatsHttpd(stats_httpd.StatsHttpd):
Naoki Kambe's avatar
Naoki Kambe committed
475
476
    ORIG_SPECFILE_LOCATION = stats_httpd.SPECFILE_LOCATION
    def __init__(self, *server_address):
477
        self._started = threading.Event()
Naoki Kambe's avatar
Naoki Kambe committed
478
        if server_address:
479
            stats_httpd.SPECFILE_LOCATION = self.create_specfile(*server_address)
Naoki Kambe's avatar
Naoki Kambe committed
480
481
482
            try:
                stats_httpd.StatsHttpd.__init__(self)
            finally:
483
484
                if hasattr(stats_httpd.SPECFILE_LOCATION, "close"):
                    stats_httpd.SPECFILE_LOCATION.close()
Naoki Kambe's avatar
Naoki Kambe committed
485
486
487
488
                stats_httpd.SPECFILE_LOCATION = self.ORIG_SPECFILE_LOCATION
        else:
            stats_httpd.StatsHttpd.__init__(self)

489
490
491
492
493
494
495
496
497
498
499
500
501
502
    def create_specfile(self, *server_address):
        spec_io = open(self.ORIG_SPECFILE_LOCATION)
        try:
            spec = json.load(spec_io)
            spec_io.close()
            config = spec['module_spec']['config_data']
            for i in range(len(config)):
                if config[i]['item_name'] == 'listen_on':
                    config[i]['item_default'] = \
                        [ dict(address=a[0], port=a[1]) for a in server_address ]
                    break
            return io.StringIO(json.dumps(spec))
        finally:
            spec_io.close()
503
504
505

    def run(self):
        self._started.set()
Naoki Kambe's avatar
Naoki Kambe committed
506
507
508
509
        try:
            self.start()
        except Exception:
            pass
510
511

    def shutdown(self):
Naoki Kambe's avatar
Naoki Kambe committed
512
        self.command_handler('shutdown', None)
513
514

class BaseModules:
515
    def __init__(self):
516
        # MockMsgq
517
        self.msgq = ThreadingServerManager(MockMsgq)
518
        self.msgq.run()
Naoki Kambe's avatar
Naoki Kambe committed
519
520
        # Check whether msgq is ready. A SessionTimeout is raised here if not.
        isc.cc.session.Session().close()
521
        # MockCfgmgr
522
        self.cfgmgr = ThreadingServerManager(MockCfgmgr)
523
524
        self.cfgmgr.run()
        # MockBoss
525
        self.boss = ThreadingServerManager(MockBoss)
526
        self.boss.run()
527
528
529
        # MockAuth
        self.auth = ThreadingServerManager(MockAuth)
        self.auth.run()
530
531
532
        self.auth2 = ThreadingServerManager(MockAuth)
        self.auth2.run()

533
534
535

    def shutdown(self):
        # MockAuth
536
        self.auth2.shutdown()
537
538
539
540
541
542
543
        self.auth.shutdown()
        # MockBoss
        self.boss.shutdown()
        # MockCfgmgr
        self.cfgmgr.shutdown()
        # MockMsgq
        self.msgq.shutdown()
Naoki Kambe's avatar
Naoki Kambe committed
544
545
546
547
548
549
550
        # remove the unused socket file
        socket_file = self.msgq.server.msgq.socket_file
        try:
            if os.path.exists(socket_file):
                os.remove(socket_file)
        except OSError:
            pass