test/test_livestatus.py

   1 #!/usr/bin/env python2.6
   2 # -*- coding: utf-8 -*-
   3
   4 #Copyright (C) 2009-2010 :
   5 #    Gabes Jean, naparuba@gmail.com
   6 #    Gerhard Lausser, Gerhard.Lausser@consol.de
   7 #
   8 #This file is part of Shinken.
   9 #
  10 #Shinken is free software: you can redistribute it and/or modify
  11 #it under the terms of the GNU Affero General Public License as published by
  12 #the Free Software Foundation, either version 3 of the License, or
  13 #(at your option) any later version.
  14 #
  15 #Shinken is distributed in the hope that it will be useful,
  16 #but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 #GNU Affero General Public License for more details.
  19 #
  20 #You should have received a copy of the GNU Affero General Public License
  21 #along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
  22
  23
  24 #
  25 # This file is used to test host- and service-downtimes.
  26 #
  27
  28 from shinken_test import *
  29 import os
  30 import re
  31 import subprocess
  32 import shutil
  33 import time
  34 import random
  35 import copy
  36
  37 from shinken.brok import Brok
  38 from shinken.objects.timeperiod import Timeperiod
  39 from shinken.objects.module import Module
  40 from shinken.comment import Comment
  41
  42 from shinken.modules import livestatus_broker
  43 from shinken.modules.livestatus_broker import Livestatus_broker
  44
  45 sys.setcheckinterval(10000)
  46
  47 modconf = Module()
  48 modconf.module_name = "livestatus"
  49 modconf.module_type = livestatus_broker.properties['type']
  50 modconf.properties = livestatus_broker.properties.copy()
  51
  52 class TestConfig(ShinkenTest):
  53     def contains_line(self, text, pattern):
  54         regex = re.compile(pattern)
  55         for line in text.splitlines():
  56             if re.search(regex, line):
  57                 return True
  58         return False
  59
  60
  61     def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61):
  62         super(TestConfig, self).scheduler_loop(count, reflist, do_sleep, sleep_time)
  63         if self.nagios_installed() and hasattr(self, 'nagios_started'):
  64             self.nagios_loop(1, reflist)
  65
  66
  67     def update_broker(self, dodeepcopy=False):
  68         #The brok should be manage in the good order
  69         ids = self.sched.broks.keys()
  70         ids.sort()
  71         for brok_id in ids:
  72             brok = self.sched.broks[brok_id]
  73             #print "Managing a brok type", brok.type, "of id", brok_id
  74             #if brok.type == 'update_service_status':
  75             #    print "Problem?", brok.data['is_problem']
  76             if dodeepcopy:
  77                 brok = copy.deepcopy(brok)
  78             self.livestatus_broker.manage_brok(brok)
  79         self.sched.broks = {}
  80
  81
  82     def lines_equal(self, text1, text2):
  83         # gets two multiline strings and compares the contents
  84         # lifestatus output may not be in alphabetical order, so this
  85         # function is used to compare unordered output with unordered
  86         # expected output
  87         # sometimes mklivestatus returns 0 or 1 on an empty result
  88         text1 = text1.replace("200           1", "200           0")
  89         text2 = text2.replace("200           1", "200           0")
  90         text1 = text1.rstrip()
  91         text2 = text2.rstrip()
  92         #print "text1 //%s//" % text1
  93         #print "text2 //%s//" % text2
  94         sorted1 = "\n".join(sorted(text1.split("\n")))
  95         sorted2 = "\n".join(sorted(text2.split("\n")))
  96         len1 = len(text1.split("\n"))
  97         len2 = len(text2.split("\n"))
  98         #print "%s == %s text cmp %s" % (len1, len2, sorted1 == sorted2)
  99         #print "text1 //%s//" % sorted(text1.split("\n"))
 100         #print "text2 //%s//" % sorted(text2.split("\n"))
 101         if sorted1 == sorted2 and len1 == len2:
 102             return True
 103         else:
 104             # Maybe list members are different
 105             # allhosts;test_host_0;test_ok_0;servicegroup_02,servicegroup_01,ok
 106             # allhosts;test_host_0;test_ok_0;servicegroup_02,ok,servicegroup_01
 107             # break it up to
 108             # [['allhosts'], ['test_host_0'], ['test_ok_0'],
 109             #     ['ok', 'servicegroup_01', 'servicegroup_02']]
 110             [line for line in sorted(text1.split("\n"))]
 111             data1 = [[sorted(c.split(',')) for c in columns] for columns in [line.split(';') for line in sorted(text1.split("\n")) if line]]
 112             data2 = [[sorted(c.split(',')) for c in columns] for columns in [line.split(';') for line in sorted(text2.split("\n")) if line]]
 113             #print "text1 //%s//" % data1
 114             #print "text2 //%s//" % data2
 115             # cmp is clever enough to handle nested arrays
 116             return cmp(data1, data2) == 0
 117
 118
 119     def show_broks(self, title):
 120         print
 121         print "--- ", title
 122         for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
 123             if re.compile('^service_').match(brok.type):
 124                 print "BROK:", brok.type
 125                 print "BROK   ", brok.data['in_checking']
 126         self.update_broker()
 127         request = 'GET services\nColumns: service_description is_executing\n'
 128         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 129         print response
 130
 131
 132     def nagios_installed(self, path='/usr/local/nagios/bin/nagios', livestatus='/usr/local/nagios/lib/mk-livestatus/livestatus.o'):
 133         return False
 134         raise
 135         if os.path.exists(path) and os.access(path, os.X_OK) and os.path.exists(livestatus):
 136             self.nagios_path = path
 137             self.livestatus_path = livestatus
 138             return True
 139         else:
 140             return False
 141
 142
 143     # shinkenize_nagios_config('nagios_1r_1h_1s')
 144     # We assume that there is a nagios_1r_1h_1s.cfg and a nagios_1r_1h_1s directory for the objects
 145     def unshinkenize_config(self, configname):
 146         new_configname = configname + '_' + str(os.getpid())
 147         config = open('etc/nagios_' + configname + '.cfg')
 148         text = config.readlines()
 149         config.close()
 150
 151         newconfig = open('etc/nagios_' + new_configname + '.cfg', 'w')
 152         for line in text:
 153             if re.search('^resource_file=', line):
 154                 newconfig.write("resource_file=etc/resource.cfg\n")
 155             elif re.search('shinken\-specific\.cfg', line):
 156                 pass
 157             elif re.search('enable_problem_impacts_states_change', line):
 158                 pass
 159             elif re.search('cfg_dir=', line):
 160                 newconfig.write(re.sub(configname, new_configname, line))
 161             elif re.search('cfg_file=', line):
 162                 newconfig.write(re.sub(configname, new_configname, line))
 163             elif re.search('execute_host_checks=', line):
 164                 newconfig.write("execute_host_checks=0\n")
 165             elif re.search('execute_service_checks=', line):
 166                 newconfig.write("execute_service_checks=0\n")
 167             elif re.search('^debug_level=', line):
 168                 newconfig.write("debug_level=0\n")
 169             elif re.search('^debug_verbosity=', line):
 170                 newconfig.write("debug_verbosity=0\n")
 171             elif re.search('^status_update_interval=', line):
 172                 newconfig.write("status_update_interval=30\n")
 173             elif re.search('^command_file=', line):
 174                 newconfig.write("command_file=var/nagios.cmd\n")
 175             elif re.search('^command_check_interval=', line):
 176                 newconfig.write("command_check_interval=1s\n")
 177             else:
 178                 newconfig.write(line)
 179         newconfig.write('broker_module=/usr/local/nagios/lib/mk-livestatus/livestatus.o var/live' + "\n")
 180         newconfig.close()
 181         for dirfile in os.walk('etc/' + configname):
 182             dirpath, dirlist, filelist = dirfile
 183             newdirpath = re.sub(configname, new_configname, dirpath)
 184             os.mkdir(newdirpath)
 185             for file in [f for f in filelist if re.search('\.cfg$', f)]:
 186                 config = open(dirpath + '/' + file)
 187                 text = config.readlines()
 188                 config.close()
 189                 newconfig = open(newdirpath + '/' + file, 'w')
 190                 for line in text:
 191                     if re.search('^\s*criticity', line):
 192                         pass
 193                     elif re.search('enable_problem_impacts_states_change', line):
 194                         pass
 195                     else:
 196                         newconfig.write(line)
 197                 newconfig.close()
 198         return new_configname
 199
 200
 201     def start_nagios(self, config):
 202         if os.path.exists('var/spool/checkresults'):
 203             # Cleanup leftover checkresults
 204             shutil.rmtree('var/spool/checkresults')
 205         for dir in ['tmp', 'var/tmp', 'var/spool', 'var/spool/checkresults', 'var/archives']:
 206             if not os.path.exists(dir):
 207                 os.mkdir(dir)
 208         self.nagios_config = self.unshinkenize_config(config)
 209         if os.path.exists('var/nagios.log'):
 210             os.remove('var/nagios.log')
 211         if os.path.exists('var/retention.dat'):
 212             os.remove('var/retention.dat')
 213         if os.path.exists('var/status.dat'):
 214             os.remove('var/status.dat')
 215         self.nagios_proc = subprocess.Popen([self.nagios_path, 'etc/nagios_' + self.nagios_config + '.cfg'], close_fds=True)
 216         self.nagios_started = time.time()
 217         time.sleep(2)
 218
 219
 220     def stop_nagios(self):
 221         if self.nagios_installed():
 222             print "i stop nagios!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
 223             time.sleep(5)
 224             if hasattr(self, 'nagios_proc'):
 225                 attempt = 1
 226                 while self.nagios_proc.poll() is None and attempt < 4:
 227                     self.nagios_proc.terminate()
 228                     attempt += 1
 229                     time.sleep(1)
 230                 if self.nagios_proc.poll() is None:
 231                     self.nagios_proc.kill()
 232                 if os.path.exists('etc/' + self.nagios_config):
 233                     shutil.rmtree('etc/' + self.nagios_config)
 234                 if os.path.exists('etc/nagios_' + self.nagios_config + '.cfg'):
 235                     os.remove('etc/nagios_' + self.nagios_config + '.cfg')
 236
 237
 238     def ask_nagios(self, request):
 239         if time.time() - self.nagios_started < 2:
 240             time.sleep(1)
 241         if not request.endswith("\n"):
 242             request = request + "\n"
 243         unixcat = subprocess.Popen([os.path.dirname(self.nagios_path) + '/' + 'unixcat', 'var/live'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 244         tic = time.clock()
 245         out, err = unixcat.communicate(request)
 246         tac = time.clock()
 247         print "mklivestatus duration %f" % (tac - tic)
 248         attempt = 1
 249         while unixcat.poll() is None and attempt < 4:
 250             unixcat.terminate()
 251             attempt += 1
 252             time.sleep(1)
 253         if unixcat.poll() is None:
 254             unixcat.kill()
 255         print "unixcat says", out
 256         return out
 257
 258
 259     def nagios_loop(self, count, reflist, do_sleep=False, sleep_time=61):
 260         now = time.time()
 261         buffer = open('var/pipebuffer', 'w')
 262         for ref in reflist:
 263             (obj, exit_status, output) = ref
 264             if obj.my_type == 'service':
 265                 cmd = "[%lu] PROCESS_SERVICE_CHECK_RESULT;%s;%s;%d;%s\n" % (now, obj.host_name, obj.service_description, exit_status, output)
 266                 print cmd
 267                 buffer.write(cmd)
 268             else:
 269                 cmd = "[%lu] PROCESS_HOST_CHECK_RESULT;%s;%d;%s\n" % (now, obj.host_name, exit_status, output)
 270                 buffer.write(cmd)
 271         buffer.close()
 272         print "open pipe", self.conf.command_file
 273         fifo = open('var/nagios.cmd', 'w')
 274         cmd = "[%lu] PROCESS_FILE;%s;0\n" % (now, 'var/pipebuffer')
 275         fifo.write(cmd)
 276         fifo.flush()
 277         fifo.close()
 278         time.sleep(5)
 279
 280
 281     def nagios_extcmd(self, cmd):
 282         fifo = open('var/nagios.cmd', 'w')
 283         fifo.write(cmd)
 284         fifo.flush()
 285         fifo.close()
 286         time.sleep(5)
 287
 288
 289
 290 class TestConfigSmall(TestConfig):
 291     def setUp(self):
 292         self.setup_with_file('etc/nagios_1r_1h_1s.cfg')
 293         Comment.id = 1
 294         self.testid = str(os.getpid() + random.randint(1, 1000))
 295         self.livelogs = 'tmp/livelogs.db' + self.testid
 296         self.pnp4nagios = 'tmp/pnp4nagios_test' + self.testid
 297         self.livestatus_broker = Livestatus_broker(modconf, '127.0.0.1', str(50000 + os.getpid()), 'live', [], self.livelogs, 365, self.pnp4nagios)
 298         self.livestatus_broker.create_queues()
 299         #self.livestatus_broker.properties = {
 300         #    'to_queue' : 0,
 301         #    'from_queue' : 0
 302         #
 303         #    }
 304         self.livestatus_broker.init()
 305         print "Cleaning old broks?"
 306         self.sched.fill_initial_broks()
 307         self.update_broker()
 308         self.nagios_path = None
 309         self.livestatus_path = None
 310         self.nagios_config = None
 311
 312
 313
 314     def tearDown(self):
 315         self.stop_nagios()
 316         self.livestatus_broker.dbconn.commit()
 317         self.livestatus_broker.dbconn.close()
 318         if os.path.exists(self.livelogs):
 319             os.remove(self.livelogs)
 320         if os.path.exists(self.pnp4nagios):
 321             shutil.rmtree(self.pnp4nagios)
 322         if os.path.exists('var/nagios.log'):
 323             os.remove('var/nagios.log')
 324         if os.path.exists('var/retention.dat'):
 325             os.remove('var/retention.dat')
 326         if os.path.exists('var/status.dat'):
 327             os.remove('var/status.dat')
 328
 329
 330     def test_childs(self):
 331         if self.nagios_installed():
 332             self.start_nagios('1r_1h_1s')
 333         self.print_header()
 334         now = time.time()
 335         objlist = []
 336         for host in self.sched.hosts:
 337             objlist.append([host, 0, 'UP'])
 338         for service in self.sched.services:
 339             objlist.append([service, 0, 'OK'])
 340         self.scheduler_loop(1, objlist)
 341         self.update_broker()
 342         request = """GET hosts
 343 Columns: childs
 344 Filter: name = test_host_0
 345 OutputFormat: csv
 346 KeepAlive: on
 347 ResponseHeader: fixed16
 348 """
 349         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 350         print response
 351         if self.nagios_installed():
 352             nagresponse = self.ask_nagios(request)
 353             print "nagresponse----------------------------------------------"
 354             print nagresponse
 355             self.assert_(self.lines_equal(response, nagresponse))
 356         request = """GET hosts
 357 Columns: childs
 358 Filter: name = test_router_0
 359 OutputFormat: csv
 360 KeepAlive: on
 361 ResponseHeader: fixed16
 362 """
 363         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 364         print response
 365         if self.nagios_installed():
 366             nagresponse = self.ask_nagios(request)
 367             print "nagresponse----------------------------------------------"
 368             print nagresponse
 369             self.assert_(self.lines_equal(response, nagresponse))
 370
 371
 372
 373     def test_servicesbyhostgroup(self):
 374         if self.nagios_installed():
 375             self.start_nagios('1r_1h_1s')
 376         self.print_header()
 377         now = time.time()
 378         objlist = []
 379         for host in self.sched.hosts:
 380             objlist.append([host, 0, 'UP'])
 381         for service in self.sched.services:
 382             objlist.append([service, 0, 'OK'])
 383         self.scheduler_loop(1, objlist)
 384         self.update_broker()
 385         request = """GET servicesbyhostgroup
 386 Filter: host_groups >= allhosts
 387 Columns: hostgroup_name host_name service_description groups
 388 OutputFormat: csv
 389 KeepAlive: on
 390 ResponseHeader: fixed16
 391 """
 392         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 393         print response
 394         if self.nagios_installed():
 395             nagresponse = self.ask_nagios(request)
 396             print "nagresponse----------------------------------------------"
 397             print nagresponse
 398             self.assert_(self.lines_equal(response, nagresponse))
 399
 400         # Again, but without filter
 401         request = """GET servicesbyhostgroup
 402 Columns: hostgroup_name host_name service_description groups
 403 OutputFormat: csv
 404 KeepAlive: on
 405 ResponseHeader: fixed16
 406 """
 407         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 408         print response
 409         if self.nagios_installed():
 410             nagresponse = self.ask_nagios(request)
 411             print "nagresponse----------------------------------------------"
 412             print nagresponse
 413             self.assert_(self.lines_equal(response, nagresponse))
 414
 415
 416     def test_hostsbygroup(self):
 417         self.print_header()
 418         if self.nagios_installed():
 419             self.start_nagios('1r_1h_1s')
 420         now = time.time()
 421         objlist = []
 422         for host in self.sched.hosts:
 423             objlist.append([host, 0, 'UP'])
 424         for service in self.sched.services:
 425             objlist.append([service, 0, 'OK'])
 426         self.scheduler_loop(1, objlist)
 427         self.update_broker()
 428         request = """GET hostsbygroup
 429 ColumnHeaders: on
 430 Columns: host_name hostgroup_name
 431 Filter: groups >= allhosts
 432 OutputFormat: csv
 433 KeepAlive: on
 434 ResponseHeader: fixed16
 435 """
 436
 437         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 438         print response
 439         if self.nagios_installed():
 440             nagresponse = self.ask_nagios(request)
 441             print "nagresponse----------------------------------------------"
 442             print nagresponse
 443             self.assert_(self.lines_equal(response, nagresponse))
 444
 445
 446     def test_status(self):
 447         self.print_header()
 448         if self.nagios_installed():
 449             self.start_nagios('1r_1h_1s')
 450         now = time.time()
 451         host = self.sched.hosts.find_by_name("test_host_0")
 452         host.checks_in_progress = []
 453         host.act_depend_of = [] # ignore the router
 454         router = self.sched.hosts.find_by_name("test_router_0")
 455         router.checks_in_progress = []
 456         router.act_depend_of = [] # ignore the router
 457         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 458         svc.checks_in_progress = []
 459         svc.act_depend_of = [] # no hostchecks on critical checkresults
 460         self.scheduler_loop(2, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 2, 'BAD']])
 461         self.update_broker(True)
 462         #---------------------------------------------------------------
 463         # get the full hosts table
 464         #---------------------------------------------------------------
 465         request = 'GET hosts'
 466         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 467         print response
 468         if self.nagios_installed():
 469             nagresponse = self.ask_nagios(request)
 470             print "nagresponse----------------------------------------------"
 471             print nagresponse
 472             # todo 1 != 1.0000000000e+00
 473             #self.assert_(self.lines_equal(response, nagresponse))
 474
 475         #---------------------------------------------------------------
 476         # get only the host names and addresses
 477         #---------------------------------------------------------------
 478         request = 'GET hosts\nColumns: name address groups\nColumnHeaders: on'
 479         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 480         print response
 481         if self.nagios_installed():
 482             nagresponse = self.ask_nagios(request)
 483             print "nagresponse----------------------------------------------"
 484             print nagresponse
 485             self.assert_(self.lines_equal(response, nagresponse))
 486
 487         #---------------------------------------------------------------
 488         # query_1
 489         #---------------------------------------------------------------
 490         request = 'GET contacts'
 491         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 492         print 'query_1_______________\n%s\n%s\n' % (request, response)
 493         if self.nagios_installed():
 494             nagresponse = self.ask_nagios(request)
 495             print "nagresponse----------------------------------------------"
 496             print nagresponse
 497             # There are some sick columns in the livestatus response like
 498             # modified_attributes;modified_attributes_list
 499             # These are not implemented in shinken-livestatus (never, i think)
 500             #self.assert_(self.lines_equal(response, nagresponse))
 501
 502         #---------------------------------------------------------------
 503         # query_2
 504         #---------------------------------------------------------------
 505         request = 'GET contacts\nColumns: name alias'
 506         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 507         print 'query_2_______________\n%s\n%s\n' % (request, response)
 508         if self.nagios_installed():
 509             nagresponse = self.ask_nagios(request)
 510             print "nagresponse----------------------------------------------"
 511             print nagresponse
 512             self.assert_(self.lines_equal(response, nagresponse))
 513
 514         #---------------------------------------------------------------
 515         # query_3
 516         #---------------------------------------------------------------
 517         #self.scheduler_loop(3, svc, 2, 'BAD')
 518         request = 'GET services\nColumns: host_name description state\nFilter: state = 2\nColumnHeaders: on'
 519         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 520         print 'query_3_______________\n%s\n%s\n' % (request, response)
 521         self.assert_(response == 'host_name;description;state\ntest_host_0;test_ok_0;2\n')
 522         request = 'GET services\nColumns: host_name description state\nFilter: state = 2'
 523         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 524         print 'query_3_______________\n%s\n%s\n' % (request, response)
 525         self.assert_(response == 'test_host_0;test_ok_0;2\n')
 526         request = 'GET services\nColumns: host_name description state\nFilter: state = 0'
 527         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 528         print 'query_3_______________\n%s\n%s\n' % (request, response)
 529         self.assert_(response == '\n')
 530         duration = 180
 531         now = time.time()
 532         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_ok_0;%d;%d;0;0;%d;lausser;blablub" % (now, now, now + duration, duration)
 533         self.sched.run_external_command(cmd)
 534         self.update_broker(True)
 535         self.scheduler_loop(1, [[svc, 0, 'OK']])
 536         self.update_broker(True)
 537         self.scheduler_loop(3, [[svc, 2, 'BAD']])
 538         self.update_broker(True)
 539         request = 'GET services\nColumns: host_name description scheduled_downtime_depth\nFilter: state = 2\nFilter: scheduled_downtime_depth = 1'
 540         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 541         print 'query_3_______________\n%s\n%s\n' % (request, response)
 542         self.assert_(response == 'test_host_0;test_ok_0;1\n')
 543
 544         #---------------------------------------------------------------
 545         # query_4
 546         #---------------------------------------------------------------
 547         request = 'GET services\nColumns: host_name description state\nFilter: state = 2\nFilter: in_notification_period = 1\nAnd: 2\nFilter: state = 0\nOr: 2\nFilter: host_name = test_host_0\nFilter: description = test_ok_0\nAnd: 3\nFilter: contacts >= harri\nFilter: contacts >= test_contact\nOr: 3'
 548         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 549         print 'query_4_______________\n%s\n%s\n' % (request, response)
 550         self.assert_(response == 'test_host_0;test_ok_0;2\n')
 551
 552         #---------------------------------------------------------------
 553         # query_6
 554         #---------------------------------------------------------------
 555         request = 'GET services\nStats: state = 0\nStats: state = 1\nStats: state = 2\nStats: state = 3'
 556         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 557         print 'query_6_______________\n%s\n%s\n' % (request, response)
 558         self.assert_(response == '0;0;1;0\n')
 559
 560         #---------------------------------------------------------------
 561         # query_7
 562         #---------------------------------------------------------------
 563         request = 'GET services\nStats: state = 0\nStats: state = 1\nStats: state = 2\nStats: state = 3\nFilter: contacts >= test_contact'
 564         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 565         print 'query_6_______________\n%s\n%s\n' % (request, response)
 566         self.assert_(response == '0;0;1;0\n')
 567         if self.nagios_installed():
 568             nagresponse = self.ask_nagios(request)
 569             print "nagresponse----------------------------------------------"
 570             print nagresponse
 571             # TODO looks like a timing problem with nagios
 572             #self.assert_(self.lines_equal(response, nagresponse))
 573
 574
 575     def test_json(self):
 576         self.print_header()
 577         print "got initial broks"
 578         now = time.time()
 579         host = self.sched.hosts.find_by_name("test_host_0")
 580         host.checks_in_progress = []
 581         host.act_depend_of = [] # ignore the router
 582         router = self.sched.hosts.find_by_name("test_router_0")
 583         router.checks_in_progress = []
 584         router.act_depend_of = [] # ignore the router
 585         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 586         svc.checks_in_progress = []
 587         svc.act_depend_of = [] # no hostchecks on critical checkresults
 588         self.scheduler_loop(2, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 2, 'BAD']])
 589         self.update_broker()
 590         request = 'GET services\nColumns: host_name description state\nOutputFormat: json'
 591         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 592         print 'json wo headers__________\n%s\n%s\n' % (request, response)
 593         self.assert_(response == '[["test_host_0","test_ok_0",2]]\n')
 594         request = 'GET services\nColumns: host_name description state\nOutputFormat: json\nColumnHeaders: on'
 595         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 596         print 'json with headers__________\n%s\n%s\n' % (request, response)
 597         self.assert_(response == '[["host_name","description","state"],["test_host_0","test_ok_0",2]]\n')
 598         #100% mklivesttaus: self.assert_(response == '[["host_name","description","state"],\n["test_host_0","test_ok_0",2]]\n')
 599
 600
 601     def test_thruk(self):
 602         self.print_header()
 603         if self.nagios_installed():
 604             self.start_nagios('1r_1h_1s')
 605         now = time.time()
 606         host = self.sched.hosts.find_by_name("test_host_0")
 607         host.checks_in_progress = []
 608         host.act_depend_of = [] # ignore the router
 609         router = self.sched.hosts.find_by_name("test_router_0")
 610         router.checks_in_progress = []
 611         router.act_depend_of = [] # ignore the router
 612         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 613         svc.checks_in_progress = []
 614         svc.act_depend_of = [] # no hostchecks on critical checkresults
 615         self.scheduler_loop(2, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 2, 'BAD']])
 616         self.update_broker()
 617         #---------------------------------------------------------------
 618         # get the full hosts table
 619         #---------------------------------------------------------------
 620         request = 'GET status\nColumns: livestatus_version program_version accept_passive_host_checks accept_passive_service_checks check_external_commands check_host_freshness check_service_freshness enable_event_handlers enable_flap_detection enable_notifications execute_host_checks execute_service_checks last_command_check last_log_rotation nagios_pid obsess_over_hosts obsess_over_services process_performance_data program_start interval_length'
 621         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 622         print response
 623
 624         request = """GET hosts
 625 Stats: name !=
 626 Stats: check_type = 0
 627 Stats: check_type = 1
 628 Stats: has_been_checked = 1
 629 Stats: state = 0
 630 StatsAnd: 2
 631 Stats: has_been_checked = 1
 632 Stats: state = 1
 633 StatsAnd: 2
 634 Stats: has_been_checked = 1
 635 Stats: state = 2
 636 StatsAnd: 2
 637 Stats: has_been_checked = 0
 638 Stats: has_been_checked = 0
 639 Stats: active_checks_enabled = 0
 640 StatsAnd: 2
 641 Stats: has_been_checked = 0
 642 Stats: scheduled_downtime_depth > 0
 643 StatsAnd: 2
 644 Stats: state = 0
 645 Stats: has_been_checked = 1
 646 Stats: active_checks_enabled = 0
 647 StatsAnd: 3
 648 Stats: state = 0
 649 Stats: has_been_checked = 1
 650 Stats: scheduled_downtime_depth > 0
 651 StatsAnd: 3
 652 Stats: state = 1
 653 Stats: has_been_checked = 1
 654 Stats: acknowledged = 1
 655 StatsAnd: 3
 656 Stats: state = 1
 657 Stats: scheduled_downtime_depth > 0
 658 Stats: has_been_checked = 1
 659 StatsAnd: 3
 660 Stats: state = 1
 661 Stats: active_checks_enabled = 0
 662 Stats: has_been_checked = 1
 663 StatsAnd: 3
 664 Stats: state = 1
 665 Stats: active_checks_enabled = 1
 666 Stats: acknowledged = 0
 667 Stats: scheduled_downtime_depth = 0
 668 Stats: has_been_checked = 1
 669 StatsAnd: 5
 670 Stats: state = 2
 671 Stats: acknowledged = 1
 672 Stats: has_been_checked = 1
 673 StatsAnd: 3
 674 Stats: state = 2
 675 Stats: scheduled_downtime_depth > 0
 676 Stats: has_been_checked = 1
 677 StatsAnd: 3
 678 Stats: state = 2
 679 Stats: active_checks_enabled = 0
 680 StatsAnd: 2
 681 Stats: state = 2
 682 Stats: active_checks_enabled = 1
 683 Stats: acknowledged = 0
 684 Stats: scheduled_downtime_depth = 0
 685 Stats: has_been_checked = 1
 686 StatsAnd: 5
 687 Stats: is_flapping = 1
 688 Stats: flap_detection_enabled = 0
 689 Stats: notifications_enabled = 0
 690 Stats: event_handler_enabled = 0
 691 Stats: active_checks_enabled = 0
 692 Stats: accept_passive_checks = 0
 693 Stats: state = 1
 694 Stats: childs !=
 695 StatsAnd: 2
 696 Separators: 10 59 44 124
 697 ResponseHeader: fixed16"""
 698         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 699         print response
 700         if self.nagios_installed():
 701             nagresponse = self.ask_nagios(request)
 702             print "nagresponse----------------------------------------------"
 703             print nagresponse
 704             # TODO timing problem?
 705             #self.assert_(self.lines_equal(response, nagresponse))
 706
 707         request = """GET comments
 708 Columns: host_name source type author comment entry_time entry_type expire_time
 709 Filter: service_description ="""
 710         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 711         print response
 712         if self.nagios_installed():
 713             nagresponse = self.ask_nagios(request)
 714             print "nagresponse----------------------------------------------"
 715             print nagresponse
 716             self.assert_(self.lines_equal(response, nagresponse))
 717
 718         request = """GET hosts
 719 Columns: comments has_been_checked state name address acknowledged notifications_enabled active_checks_enabled is_flapping scheduled_downtime_depth is_executing notes_url_expanded action_url_expanded icon_image_expanded icon_image_alt last_check last_state_change plugin_output next_check long_plugin_output
 720 Separators: 10 59 44 124
 721 ResponseHeader: fixed16"""
 722         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 723         print response
 724
 725         duration = 180
 726         now = time.time()
 727         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_warning_00;%d;%d;0;0;%d;lausser;blablubsvc" % (now, now, now + duration, duration)
 728         print cmd
 729         self.sched.run_external_command(cmd)
 730         if self.nagios_installed():
 731             self.nagios_extcmd(cmd)
 732         cmd = "[%lu] SCHEDULE_HOST_DOWNTIME;test_host_0;%d;%d;0;0;%d;lausser;blablubhost" % (now, now, now + duration, duration)
 733         print cmd
 734         self.sched.run_external_command(cmd)
 735         if self.nagios_installed():
 736             self.nagios_extcmd(cmd)
 737         self.update_broker()
 738         self.scheduler_loop(1, [[svc, 0, 'OK']])
 739         self.update_broker()
 740         self.scheduler_loop(3, [[svc, 2, 'BAD']])
 741         self.update_broker()
 742         request = """GET downtimes
 743 Filter: service_description =
 744 Columns: author comment end_time entry_time fixed host_name id start_time
 745 Separators: 10 59 44 124
 746 ResponseHeader: fixed16"""
 747         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 748         print response
 749         if self.nagios_installed():
 750             #time.sleep(10)
 751             nagresponse = self.ask_nagios(request)
 752             print "nagresponse----------------------------------------------"
 753             print nagresponse
 754             #TODO the entry_times are different. find a way to round the numbers
 755             # so that they are equal
 756             #self.assert_(self.lines_equal(response, nagresponse))
 757
 758         request = """GET comments
 759 Filter: service_description =
 760 Columns: author comment
 761 Separators: 10 59 44 124
 762 ResponseHeader: fixed16"""
 763         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 764         print response
 765         if self.nagios_installed():
 766             time.sleep(10)
 767             nagresponse = self.ask_nagios(request)
 768             print "nagresponse----------------------------------------------"
 769             print nagresponse
 770             #self.assert_(self.lines_equal(response, nagresponse))
 771
 772         request = """GET services
 773 Filter: has_been_checked = 1
 774 Filter: check_type = 0
 775 Stats: sum has_been_checked
 776 Stats: sum latency
 777 Separators: 10 59 44 124
 778 ResponseHeader: fixed16"""
 779         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 780         print response
 781
 782         request = """GET services
 783 Filter: has_been_checked = 1
 784 Filter: check_type = 0
 785 Stats: sum has_been_checked
 786 Stats: sum latency
 787 Stats: sum execution_time
 788 Stats: min latency
 789 Stats: min execution_time
 790 Stats: max latency
 791 Stats: max execution_time
 792 Separators: 10 59 44 124
 793 ResponseHeader: fixed16"""
 794         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 795         print response
 796
 797         request = """GET services\nFilter: has_been_checked = 1\nFilter: check_type = 0\nStats: sum has_been_checked as has_been_checked\nStats: sum latency as latency_sum\nStats: sum execution_time as execution_time_sum\nStats: min latency as latency_min\nStats: min execution_time as execution_time_min\nStats: max latency as latency_max\nStats: max execution_time as execution_time_max\n\nResponseHeader: fixed16"""
 798         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 799         print response
 800
 801         request = """GET hostgroups\nColumnHeaders: on\nResponseHeader: fixed16"""
 802         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 803         print response
 804         if self.nagios_installed():
 805             nagresponse = self.ask_nagios(request)
 806             print "nagresponse----------------------------------------------"
 807             print nagresponse
 808             # TODO members_with_state
 809             #self.assert_(self.lines_equal(response, nagresponse))
 810
 811         request = """GET hosts\nColumns: name groups\nColumnHeaders: on\nResponseHeader: fixed16"""
 812         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 813         print response
 814         if self.nagios_installed():
 815             nagresponse = self.ask_nagios(request)
 816             print "nagresponse----------------------------------------------"
 817             print nagresponse
 818             self.assert_(self.lines_equal(response, nagresponse))
 819
 820         request = """GET hostgroups\nColumns: name num_services num_services_ok\nColumnHeaders: on\nResponseHeader: fixed16"""
 821         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 822         print response
 823         if self.nagios_installed():
 824             nagresponse = self.ask_nagios(request)
 825             print "nagresponse----------------------------------------------"
 826             print nagresponse
 827             self.assert_(self.lines_equal(response, nagresponse))
 828
 829         request = """GET hostgroups\nColumns: name num_services_pending num_services_ok num_services_warn num_services_crit num_services_unknown worst_service_state worst_service_hard_state\nColumnHeaders: on\nResponseHeader: fixed16"""
 830         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 831         print response
 832
 833         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']])
 834         self.update_broker()
 835         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
 836         self.update_broker()
 837
 838         print "WARNING SOFT;1"
 839         # worst_service_state 1, worst_service_hard_state 0
 840         request = """GET hostgroups\nColumns: name num_services_pending num_services_ok num_services_warn num_services_crit num_services_unknown worst_service_state worst_service_hard_state\nColumnHeaders: on\nResponseHeader: fixed16"""
 841         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 842         print response
 843         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
 844         self.update_broker()
 845         print "WARNING HARD;3"
 846         # worst_service_state 1, worst_service_hard_state 1
 847         request = """GET hostgroups\nColumns: name num_services_pending num_services_ok num_services_warn num_services_crit num_services_unknown worst_service_state worst_service_hard_state\nColumnHeaders: on\nResponseHeader: fixed16"""
 848         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 849         print response
 850         for s in self.livestatus_broker.livestatus.services.values():
 851             print "%s %d %s;%d" % (s.state, s.state_id, s.state_type, s.attempt)
 852
 853
 854     def test_thruk_comments(self):
 855         self.print_header()
 856         host = self.sched.hosts.find_by_name("test_host_0")
 857         host.checks_in_progress = []
 858         host.act_depend_of = [] # ignore the router
 859         router = self.sched.hosts.find_by_name("test_router_0")
 860         router.checks_in_progress = []
 861         router.act_depend_of = [] # ignore the router
 862         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 863         svc.checks_in_progress = []
 864         svc.act_depend_of = [] # no hostchecks on critical checkresults
 865         duration = 600
 866         now = time.time()
 867         # downtime valid for the next 2 minutes
 868         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_ok_0;%d;%d;1;0;%d;lausser;blablub" % (now, now, now + duration, duration)
 869         self.sched.run_external_command(cmd)
 870         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 871         svc.checks_in_progress = []
 872         svc.act_depend_of = [] # no hostchecks on critical checkresults
 873         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
 874
 875         print "downtime was scheduled. check its activity and the comment"
 876         self.assert_(len(self.sched.downtimes) == 1)
 877         self.assert_(len(svc.downtimes) == 1)
 878         self.assert_(svc.downtimes[0] in self.sched.downtimes.values())
 879         self.assert_(svc.downtimes[0].fixed)
 880         self.assert_(svc.downtimes[0].is_in_effect)
 881         self.assert_(not svc.downtimes[0].can_be_deleted)
 882         self.assert_(len(self.sched.comments) == 1)
 883         self.assert_(len(svc.comments) == 1)
 884         self.assert_(svc.comments[0] in self.sched.comments.values())
 885         self.assert_(svc.downtimes[0].comment_id == svc.comments[0].id)
 886
 887         now = time.time()
 888         cmd = "[%lu] ADD_SVC_COMMENT;test_host_0;test_ok_0;1;lausser;comment" % now
 889         self.sched.run_external_command(cmd)
 890         #cmd = "[%lu] ADD_HOST_COMMENT;test_host_0;1;lausser;hcomment" % now
 891         #self.sched.run_external_command(cmd)
 892         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
 893         self.assert_(len(self.sched.comments) == 2)
 894         self.assert_(len(svc.comments) == 2)
 895
 896         self.update_broker()
 897         svc_comment_list = (',').join([str(c.id) for c in svc.comments])
 898
 899         #request = """GET comments\nColumns: host_name service_description id source type author comment entry_time entry_type persistent expire_time expires\nFilter: service_description !=\nResponseHeader: fixed16\nOutputFormat: json\n"""
 900         request = """GET services\nColumns: comments host_comments host_is_executing is_executing\nFilter: service_description !=\nResponseHeader: fixed16\nOutputFormat: json\n"""
 901         response, _ = self.livestatus_broker.livestatus.handle_request(request)
 902 #        print response
 903         good_response = """200          17
 904 [[[""" + svc_comment_list +"""],[],0,0]]
 905 """
 906         self.assert_(response == good_response) # json
 907
 908         request = """GET services\nColumns: comments host_comments host_is_executing is_executing\nFilter: service_description !=\nResponseHeader: fixed16\n"""
 909         response, _ = self.livestatus_broker.livestatus.handle_request(request)
 910 #        print response
 911         good_response = """200           9
 912 """ + svc_comment_list + """;;0;0
 913 """
 914         self.assert_(response == good_response) # csv
 915
 916         request = """GET comments\n\
 917 Columns: author entry_type expires expire_time host_name id persistent service_description source type\n\
 918 Filter: service_description !=\n\
 919 Filter: service_description =\n\
 920 Or: 2\n\
 921 OutputFormat: json\n\
 922 ResponseHeader: fixed16\n"""
 923         response, _ = self.livestatus_broker.livestatus.handle_request(request)
 924         good_response = """200         115
 925 [["(Nagios Process)",2,0,0,"test_host_0",1,0,"test_ok_0",0,2],["lausser",1,0,0,"test_host_0",2,1,"test_ok_0",1,2]]
 926 """
 927         self.assert_(response == good_response)
 928
 929
 930     def test_thruk_logs(self):
 931         self.print_header()
 932         start = time.time()
 933         host = self.sched.hosts.find_by_name("test_host_0")
 934         host.checks_in_progress = []
 935         host.act_depend_of = [] # ignore the router
 936         router = self.sched.hosts.find_by_name("test_router_0")
 937         router.checks_in_progress = []
 938         router.act_depend_of = [] # ignore the router
 939         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 940         svc.checks_in_progress = []
 941         svc.act_depend_of = [] # no hostchecks on critical checkresults
 942         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
 943         self.update_broker()
 944         duration = 600
 945         now = time.time()
 946         # downtime valid for the next 2 minutes
 947         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_ok_0;%d;%d;1;0;%d;lausser;blablub" % (now, now, now + duration, duration)
 948         self.sched.run_external_command(cmd)
 949         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
 950         svc.checks_in_progress = []
 951         svc.act_depend_of = [] # no hostchecks on critical checkresults
 952         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
 953         now = time.time()
 954         cmd = "[%lu] ADD_SVC_COMMENT;test_host_0;test_ok_0;1;lausser;comment" % now
 955         self.sched.run_external_command(cmd)
 956         time.sleep(1)
 957         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
 958         self.update_broker()
 959         time.sleep(1)
 960         self.scheduler_loop(3, [[host, 2, 'DOWN'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
 961         self.update_broker()
 962         time.sleep(1)
 963         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
 964         self.update_broker()
 965         end = time.time()
 966
 967         # show history for service
 968         request = """GET log
 969 Columns: time type options state
 970 Filter: time >= """ + str(int(start)) + """
 971 Filter: time <= """ + str(int(end)) + """
 972 Filter: type = SERVICE ALERT
 973 Filter: type = HOST ALERT
 974 Filter: type = SERVICE FLAPPING ALERT
 975 Filter: type = HOST FLAPPING ALERT
 976 Filter: type = SERVICE DOWNTIME ALERT
 977 Filter: type = HOST DOWNTIME ALERT
 978 Or: 6
 979 Filter: host_name = test_host_0
 980 Filter: service_description = test_ok_0
 981 And: 3
 982 Filter: type ~ starting...
 983 Filter: type ~ shutting down...
 984 Or: 3
 985 Filter: current_service_description !=
 986
 987 Filter: service_description =
 988 Filter: host_name !=
 989 And: 2
 990 Filter: service_description =
 991 Filter: host_name =
 992 And: 2
 993 Or: 3"""
 994
 995         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
 996         print response
 997         self.assert_(self.contains_line(response, 'SERVICE DOWNTIME ALERT;test_host_0;test_ok_0;STARTED; Service has entered a period of scheduled downtime'))
 998
 999
1000     def test_thruk_logs_alerts_summary(self):
1001         self.print_header()
1002         start = time.time()
1003         host = self.sched.hosts.find_by_name("test_host_0")
1004         host.checks_in_progress = []
1005         host.act_depend_of = [] # ignore the router
1006         router = self.sched.hosts.find_by_name("test_router_0")
1007         router.checks_in_progress = []
1008         router.act_depend_of = [] # ignore the router
1009         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1010         svc.checks_in_progress = []
1011         svc.act_depend_of = [] # no hostchecks on critical checkresults
1012         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
1013         self.update_broker()
1014         duration = 600
1015         now = time.time()
1016         # downtime valid for the next 2 minutes
1017         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_ok_0;%d;%d;1;0;%d;lausser;blablub" % (now, now, now + duration, duration)
1018         self.sched.run_external_command(cmd)
1019         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1020         svc.checks_in_progress = []
1021         svc.act_depend_of = [] # no hostchecks on critical checkresults
1022         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1023         now = time.time()
1024         cmd = "[%lu] ADD_SVC_COMMENT;test_host_0;test_ok_0;1;lausser;comment" % now
1025         self.sched.run_external_command(cmd)
1026         time.sleep(1)
1027         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1028         self.update_broker()
1029         time.sleep(1)
1030         self.scheduler_loop(3, [[host, 2, 'DOWN'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1031         self.update_broker()
1032         time.sleep(1)
1033         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1034         self.update_broker()
1035         end = time.time()
1036
1037         # is this an error in thruk?
1038
1039         request = """GET log
1040 Filter: options ~ ;HARD;
1041 Filter: type = HOST ALERT
1042 Filter: time >= 1284056080
1043 Filter: time <= 1284660880
1044 Filter: current_service_description !=
1045 Filter: service_description =
1046 Filter: host_name !=
1047 And: 2
1048 Filter: service_description =
1049 Filter: host_name =
1050 And: 2
1051 Or: 3
1052 Columns: time state state_type host_name service_description current_host_groups current_service_groups plugin_output"""
1053
1054         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1055         print response
1056
1057
1058     def test_thruk_logs_current(self):
1059         self.print_header()
1060         start = time.time()
1061         host = self.sched.hosts.find_by_name("test_host_0")
1062         host.checks_in_progress = []
1063         host.act_depend_of = [] # ignore the router
1064         router = self.sched.hosts.find_by_name("test_router_0")
1065         router.checks_in_progress = []
1066         router.act_depend_of = [] # ignore the router
1067         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1068         svc.checks_in_progress = []
1069         svc.act_depend_of = [] # no hostchecks on critical checkresults
1070         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
1071         self.update_broker()
1072         duration = 600
1073         now = time.time()
1074         # downtime valid for the next 2 minutes
1075         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_ok_0;%d;%d;1;0;%d;lausser;blablub" % (now, now, now + duration, duration)
1076         self.sched.run_external_command(cmd)
1077         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1078         svc.checks_in_progress = []
1079         svc.act_depend_of = [] # no hostchecks on critical checkresults
1080         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1081         now = time.time()
1082         cmd = "[%lu] ADD_SVC_COMMENT;test_host_0;test_ok_0;1;lausser;comment" % now
1083         self.sched.run_external_command(cmd)
1084         time.sleep(1)
1085         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1086         self.update_broker()
1087         time.sleep(1)
1088         self.scheduler_loop(3, [[host, 2, 'DOWN'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1089         self.update_broker()
1090         time.sleep(1)
1091         self.scheduler_loop(3, [[host, 0, 'UUP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1092         self.update_broker()
1093 #        time.sleep(1)
1094 #        self.scheduler_loop(3, [[host, 0, 'UP'], [router, 2, 'DOWN'], [svc, 0, 'OK']], do_sleep=False)
1095 #        self.update_broker()
1096         end = time.time()
1097
1098         # show history for service
1099         request = """GET log
1100 Columns: time type options state current_host_name
1101 Filter: time >= """ + str(int(start)) + """
1102 Filter: time <= """ + str(int(end)) + """
1103 Filter: type = SERVICE ALERT
1104 Filter: type = HOST ALERT
1105 Filter: type = SERVICE FLAPPING ALERT
1106 Filter: type = HOST FLAPPING ALERT
1107 Filter: type = SERVICE DOWNTIME ALERT
1108 Filter: type = HOST DOWNTIME ALERT
1109 Or: 6
1110 Filter: current_host_name = test_host_0
1111 Filter: current_service_description = test_ok_0
1112 And: 2"""
1113         request = """GET log
1114 Columns: time type options state current_host_name
1115 Filter: time >= """ + str(int(start)) + """
1116 Filter: time <= """ + str(int(end)) + """
1117 Filter: current_host_name = test_host_0
1118 Filter: current_service_description = test_ok_0
1119 And: 2"""
1120
1121         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1122         print response
1123
1124
1125     def test_thruk_tac_svc(self):
1126         self.print_header()
1127         if self.nagios_installed():
1128             self.start_nagios('1r_1h_1s')
1129         self.update_broker()
1130
1131         start = time.time()
1132         host = self.sched.hosts.find_by_name("test_host_0")
1133         host.checks_in_progress = []
1134         host.act_depend_of = [] # ignore the router
1135         router = self.sched.hosts.find_by_name("test_router_0")
1136         router.checks_in_progress = []
1137         router.act_depend_of = [] # ignore the router
1138         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1139         svc.checks_in_progress = []
1140         svc.act_depend_of = [] # no hostchecks on critical checkresults
1141         self.scheduler_loop(3, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
1142         self.update_broker()
1143         duration = 600
1144         now = time.time()
1145         # downtime valid for the next 2 minutes
1146         cmd = "[%lu] SCHEDULE_SVC_DOWNTIME;test_host_0;test_ok_0;%d;%d;1;0;%d;lausser;blablub" % (now, now, now + duration, duration)
1147         self.sched.run_external_command(cmd)
1148         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1149         svc.checks_in_progress = []
1150         svc.act_depend_of = [] # no hostchecks on critical checkresults
1151         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1152         now = time.time()
1153         cmd = "[%lu] ADD_SVC_COMMENT;test_host_0;test_ok_0;1;lausser;comment" % now
1154         self.sched.run_external_command(cmd)
1155         time.sleep(1)
1156         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1157         self.update_broker()
1158         time.sleep(1)
1159         self.scheduler_loop(3, [[host, 2, 'DOWN'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1160         self.update_broker()
1161         time.sleep(1)
1162         self.scheduler_loop(3, [[host, 0, 'UUP'], [router, 0, 'UP'], [svc, 0, 'OK']], do_sleep=False)
1163         self.update_broker()
1164 #        time.sleep(1)
1165 #        self.scheduler_loop(3, [[host, 0, 'UP'], [router, 2, 'DOWN'], [svc, 0, 'OK']], do_sleep=False)
1166 #        self.update_broker()
1167         end = time.time()
1168
1169         # show history for service
1170         request = """GET services
1171 Filter: has_been_checked = 1
1172 Filter: check_type = 0
1173 Stats: sum has_been_checked
1174 Stats: sum latency
1175 Stats: sum execution_time
1176 Stats: min latency
1177 Stats: min execution_time
1178 Stats: max latency
1179 Stats: max execution_time"""
1180
1181         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1182         print response
1183         # nagios comparison makes no sense, because the latencies/execution times will surely differ
1184         if self.nagios_installed():
1185             nagresponse = self.ask_nagios(request)
1186         #    print nagresponse
1187         #    self.assert_(self.lines_equal(response, nagresponse))
1188
1189
1190     def test_columns(self):
1191         self.print_header()
1192         self.update_broker()
1193         #---------------------------------------------------------------
1194         # get the columns meta-table
1195         #---------------------------------------------------------------
1196         request = """GET columns"""
1197         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1198         print response
1199
1200
1201     def test_scheduler_table(self):
1202         self.print_header()
1203         self.update_broker()
1204
1205         creation_tab = {'scheduler_name' : 'scheduler-1', 'address' : 'localhost', 'spare' : '0'}
1206         schedlink = SchedulerLink(creation_tab)
1207         schedlink.pythonize()
1208         schedlink.alive = True
1209         b = schedlink.get_initial_status_brok()
1210         self.sched.add(b)
1211         creation_tab = {'scheduler_name' : 'scheduler-2', 'address' : 'othernode', 'spare' : '1'}
1212         schedlink = SchedulerLink(creation_tab)
1213         schedlink.pythonize()
1214         schedlink.alive = True
1215         b2 = schedlink.get_initial_status_brok()
1216         self.sched.add(b2)
1217
1218         self.update_broker()
1219         #---------------------------------------------------------------
1220         # get the columns meta-table
1221         #---------------------------------------------------------------
1222         request = """GET schedulers"""
1223         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1224         print response
1225         good_response = """address;alive;name;port;spare;weight
1226 othernode;1;scheduler-2;7768;1;1
1227 localhost;1;scheduler-1;7768;0;1
1228 """
1229         print response, 'FUCK'
1230         print "FUCK", response, "TOTO"
1231         self.assert_(self.lines_equal(response, good_response))
1232
1233         #Now we update a scheduler state and we check
1234         #here the N2
1235         schedlink.alive = False
1236         b = schedlink.get_update_status_brok()
1237         self.sched.add(b)
1238         self.update_broker()
1239         request = """GET schedulers"""
1240         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1241         good_response = """address;alive;name;port;spare;weight
1242 othernode;0;scheduler-2;7768;1;1
1243 localhost;1;scheduler-1;7768;0;1
1244 """
1245         self.assert_(self.lines_equal(response, good_response))
1246
1247
1248
1249     def test_reactionner_table(self):
1250         self.print_header()
1251         self.update_broker()
1252         creation_tab = {'reactionner_name' : 'reactionner-1', 'address' : 'localhost', 'spare' : '0'}
1253         reac = ReactionnerLink(creation_tab)
1254         reac.pythonize()
1255         reac.alive = True
1256         b = reac.get_initial_status_brok()
1257         self.sched.add(b)
1258         creation_tab = {'reactionner_name' : 'reactionner-2', 'address' : 'othernode', 'spare' : '1'}
1259         reac = ReactionnerLink(creation_tab)
1260         reac.pythonize()
1261         reac.alive = True
1262         b2 = reac.get_initial_status_brok()
1263         self.sched.add(b2)
1264
1265         self.update_broker()
1266         #---------------------------------------------------------------
1267         # get the columns meta-table
1268         #---------------------------------------------------------------
1269         request = """GET reactionners"""
1270         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1271         print response
1272         good_response = """address;alive;name;port;spare
1273 localhost;1;reactionner-1;7769;0
1274 othernode;1;reactionner-2;7769;1
1275 """
1276         print response == good_response
1277         self.assert_(self.lines_equal(response, good_response))
1278
1279         #Now the update part
1280         reac.alive = False
1281         b2 = reac.get_update_status_brok()
1282         self.sched.add(b2)
1283         self.update_broker()
1284         request = """GET reactionners"""
1285         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1286         print response
1287         good_response = """address;alive;name;port;spare
1288 localhost;1;reactionner-1;7769;0
1289 othernode;0;reactionner-2;7769;1
1290 """
1291         print response == good_response
1292         self.assert_(self.lines_equal(response, good_response))
1293
1294
1295
1296     def test_poller_table(self):
1297         self.print_header()
1298         self.update_broker()
1299
1300         creation_tab = {'poller_name' : 'poller-1', 'address' : 'localhost', 'spare' : '0'}
1301         pol = PollerLink(creation_tab)
1302         pol.pythonize()
1303         pol.alive = True
1304         b = pol.get_initial_status_brok()
1305         self.sched.add(b)
1306         creation_tab = {'poller_name' : 'poller-2', 'address' : 'othernode', 'spare' : '1'}
1307         pol = PollerLink(creation_tab)
1308         pol.pythonize()
1309         pol.alive = True
1310         b2 = pol.get_initial_status_brok()
1311         self.sched.add(b2)
1312
1313         self.update_broker()
1314         #---------------------------------------------------------------
1315         # get the columns meta-table
1316         #---------------------------------------------------------------
1317         request = """GET pollers"""
1318         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1319         print response
1320         good_response = """address;alive;name;port;spare
1321 localhost;1;poller-1;7771;0
1322 othernode;1;poller-2;7771;1
1323 """
1324         print response == good_response
1325         self.assert_(self.lines_equal(response, good_response))
1326
1327         #Now the update part
1328         pol.alive = False
1329         b2 = pol.get_update_status_brok()
1330         self.sched.add(b2)
1331
1332         self.update_broker()
1333         #---------------------------------------------------------------
1334         # get the columns meta-table
1335         #---------------------------------------------------------------
1336         request = """GET pollers"""
1337         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1338         print response
1339         good_response = """address;alive;name;port;spare
1340 localhost;1;poller-1;7771;0
1341 othernode;0;poller-2;7771;1
1342 """
1343         print response == good_response
1344         self.assert_(self.lines_equal(response, good_response))
1345
1346
1347
1348     def test_broker_table(self):
1349         self.print_header()
1350         self.update_broker()
1351
1352         creation_tab = {'broker_name' : 'broker-1', 'address' : 'localhost', 'spare' : '0'}
1353         pol = BrokerLink(creation_tab)
1354         pol.pythonize()
1355         pol.alive = True
1356         b = pol.get_initial_status_brok()
1357         self.sched.add(b)
1358         creation_tab = {'broker_name' : 'broker-2', 'address' : 'othernode', 'spare' : '1'}
1359         pol = BrokerLink(creation_tab)
1360         pol.pythonize()
1361         pol.alive = True
1362         b2 = pol.get_initial_status_brok()
1363         self.sched.add(b2)
1364
1365         self.update_broker()
1366         #---------------------------------------------------------------
1367         # get the columns meta-table
1368         #---------------------------------------------------------------
1369         request = """GET brokers"""
1370         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1371         print response
1372         good_response = """address;alive;name;port;spare
1373 localhost;1;broker-1;7772;0
1374 othernode;1;broker-2;7772;1
1375 """
1376         print response == good_response
1377         self.assert_(self.lines_equal(response, good_response))
1378
1379         #Now the update part
1380         pol.alive = False
1381         b2 = pol.get_initial_status_brok()
1382         self.sched.add(b2)
1383
1384         self.update_broker()
1385         #---------------------------------------------------------------
1386         # get the columns meta-table
1387         #---------------------------------------------------------------
1388         request = """GET brokers"""
1389         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1390         print response
1391         good_response = """address;alive;name;port;spare
1392 localhost;1;broker-1;7772;0
1393 othernode;0;broker-2;7772;1
1394 """
1395         print response == good_response
1396         self.assert_(self.lines_equal(response, good_response))
1397
1398
1399
1400     def test_problems_table(self):
1401         self.print_header()
1402         self.update_broker()
1403         host = self.sched.hosts.find_by_name("test_host_0")
1404         host.checks_in_progress = []
1405         host.act_depend_of = [] # ignore the router
1406         router = self.sched.hosts.find_by_name("test_router_0")
1407         router.checks_in_progress = []
1408         router.act_depend_of = [] # ignore the router
1409         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1410         svc.checks_in_progress = []
1411         svc.act_depend_of = [] # no hostchecks on critical checkresults
1412         self.scheduler_loop(4, [[host, 2, 'DOWN'], [router, 2, 'DOWN'], [svc, 2, 'BAD']])
1413         print "Is router a problem?", router.is_problem, router.state, router.state_type
1414         print "Is host a problem?", host.is_problem, host.state, host.state_type
1415         print "Is service a problem?", svc.is_problem, svc.state, svc.state_type
1416         self.update_broker()
1417         print "All", self.livestatus_broker.hosts
1418         for h in self.livestatus_broker.hosts.values():
1419             print h.get_dbg_name(), h.is_problem
1420
1421         #---------------------------------------------------------------
1422         # get the columns meta-table
1423         #---------------------------------------------------------------
1424         request = """GET problems"""
1425         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1426         print "FUCK", response
1427         good_response = """impacts;source
1428 test_host_0,test_host_0/test_ok_0;test_router_0
1429 """
1430         print response == good_response
1431         self.assert_(response == good_response)
1432
1433
1434     def test_parent_childs_dep_lists(self):
1435         self.print_header()
1436         self.update_broker()
1437         host = self.sched.hosts.find_by_name("test_host_0")
1438         router = self.sched.hosts.find_by_name("test_router_0")
1439         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1440
1441         #---------------------------------------------------------------
1442         # get the columns meta-table
1443         #---------------------------------------------------------------
1444         # first test if test_router_0 is in the host parent list
1445         request = 'GET hosts\nColumns: host_name parent_dependencies\nFilter: host_name = test_host_0\n'
1446         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1447         good_response = """test_host_0;test_router_0"""
1448         self.assert_(response.strip() == good_response.strip())
1449
1450         # Now check if host is in the child router list
1451         request = 'GET hosts\nColumns: host_name child_dependencies\nFilter: host_name = test_router_0\n'
1452         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1453         good_response = """test_router_0;test_host_0"""
1454         self.assert_(response.strip() == good_response.strip())
1455
1456         # Now check with the service
1457         request = 'GET hosts\nColumns: host_name child_dependencies\nFilter: host_name = test_host_0\n'
1458         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1459         good_response = """test_host_0;test_host_0/test_ok_0"""
1460         self.assert_(response.strip() == good_response.strip())
1461
1462         # And check the parent for the service
1463         request = 'GET services\nColumns: parent_dependencies\nFilter: host_name = test_host_0\n'
1464         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1465         good_response = """test_host_0"""
1466         self.assert_(response.strip() == good_response.strip())
1467
1468
1469     def test_limit(self):
1470         self.print_header()
1471         if self.nagios_installed():
1472             self.start_nagios('1r_1h_1s')
1473         now = time.time()
1474         self.update_broker()
1475         #---------------------------------------------------------------
1476         # get the full hosts table
1477         #---------------------------------------------------------------
1478         request = 'GET hosts\nColumns: host_name\n'
1479         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1480         print response
1481         good_response = """test_host_0
1482 test_router_0
1483 """
1484         self.assert_(self.lines_equal(response, good_response))
1485
1486         request = 'GET hosts\nColumns: host_name\nLimit: 1\n'
1487         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1488         print response
1489         good_response = """test_host_0
1490 """
1491         # it must be test_host_0 because with Limit: the output is
1492         # alphabetically ordered
1493         self.assert_(response == good_response)
1494         # TODO look whats wrong
1495         if self.nagios_installed():
1496             nagresponse = self.ask_nagios(request)
1497         #    print nagresponse
1498         #    self.assert_(self.lines_equal(response, nagresponse))
1499
1500
1501
1502     def test_problem_impact_in_host_service(self):
1503         self.print_header()
1504         now = time.time()
1505         self.update_broker()
1506
1507         host_router_0 = self.sched.hosts.find_by_name("test_router_0")
1508         host_router_0.checks_in_progress = []
1509
1510         #Then initialize host under theses routers
1511         host_0 = self.sched.hosts.find_by_name("test_host_0")
1512         host_0.checks_in_progress = []
1513
1514         all_hosts = [host_router_0, host_0]
1515         all_routers = [host_router_0]
1516         all_servers = [host_0]
1517
1518         print "- 4 x UP -------------------------------------"
1519         self.scheduler_loop(1, [[host_router_0, 0, 'UP'], [host_0, 0, 'UP']], do_sleep=False)
1520         self.scheduler_loop(1, [[host_router_0, 1, 'DOWN']], do_sleep=False)
1521         self.scheduler_loop(1, [[host_router_0, 1, 'DOWN']], do_sleep=False)
1522         self.scheduler_loop(1, [[host_router_0, 1, 'DOWN']], do_sleep=False)
1523         self.scheduler_loop(1, [[host_router_0, 1, 'DOWN']], do_sleep=False)
1524         self.scheduler_loop(1, [[host_router_0, 1, 'DOWN']], do_sleep=False)
1525
1526         #Max attempt is reach, should be HARD now
1527         for h in all_routers:
1528             self.assert_(h.state == 'DOWN')
1529             self.assert_(h.state_type == 'HARD')
1530
1531         for b in self.sched.broks.values():
1532             print "All broks", b.type, b
1533             if b.type == 'update_host_status':
1534                 print "***********"
1535                 print "Impacts", b.data['impacts']
1536                 print "Sources",  b.data['source_problems']
1537
1538         for b in host_router_0.broks:
1539             print " host_router_0.broks", b
1540
1541         self.update_broker()
1542
1543         print "source de host_0", host_0.source_problems
1544         for i in host_0.source_problems:
1545             print "source", i.get_name()
1546         print "impacts de host_router_0", host_router_0.impacts
1547         for i in host_router_0.impacts:
1548             print "impact", i.get_name()
1549
1550         #---------------------------------------------------------------
1551         # get the full hosts table
1552         #---------------------------------------------------------------
1553         print "Got source problems"
1554         request = 'GET hosts\nColumns: host_name is_impact source_problems\n'
1555         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1556         print "moncullulu2", response
1557         good_response = """test_router_0;0;
1558 test_host_0;1;test_router_0
1559 """
1560         #self.assert_(self.lines_equal(response, good_response))
1561
1562         print "Now got impact"
1563         request = 'GET hosts\nColumns: host_name is_problem impacts\n'
1564         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1565         print "moncululu", response
1566         good_response = """test_router_0;1;test_host_0,test_host_0/test_ok_0
1567 test_host_0;0;"""
1568         self.assert_(self.lines_equal(response.strip(), good_response.strip()))
1569
1570         request = 'GET hosts\nColumns: host_name\nLimit: 1\n'
1571         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1572         print response
1573         good_response = """test_host_0
1574 """
1575         # it must be test_host_0 because with Limit: the output is
1576         # alphabetically ordered
1577         self.assert_(response == good_response)
1578
1579
1580
1581     def test_thruk_servicegroup(self):
1582         self.print_header()
1583         now = time.time()
1584         self.update_broker()
1585         #---------------------------------------------------------------
1586         # get services of a certain servicegroup
1587         # test_host_0/test_ok_0 is in
1588         #   servicegroup_01,ok via service.servicegroups
1589         #   servicegroup_02 via servicegroup.members
1590         #---------------------------------------------------------------
1591         request = """GET services
1592 Columns: host_name service_description
1593 Filter: groups >= servicegroup_01
1594 OutputFormat: csv
1595 ResponseHeader: fixed16
1596 """
1597         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1598         self.assert_(response == """200          22
1599 test_host_0;test_ok_0
1600 """)
1601         request = """GET services
1602 Columns: host_name service_description
1603 Filter: groups >= servicegroup_02
1604 OutputFormat: csv
1605 ResponseHeader: fixed16
1606 """
1607         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1608         self.assert_(response == """200          22
1609 test_host_0;test_ok_0
1610 """)
1611
1612
1613
1614     def test_is_executing(self):
1615         self.print_header()
1616         #---------------------------------------------------------------
1617         # make sure that the is_executing flag is updated regularly
1618         #---------------------------------------------------------------
1619         now = time.time()
1620         host = self.sched.hosts.find_by_name("test_host_0")
1621         host.checks_in_progress = []
1622         host.act_depend_of = [] # ignore the router
1623         router = self.sched.hosts.find_by_name("test_router_0")
1624         router.checks_in_progress = []
1625         router.act_depend_of = [] # ignore the router
1626         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1627         svc.checks_in_progress = []
1628         svc.act_depend_of = [] # no hostchecks on critical checkresults
1629
1630         for loop in range(1, 2):
1631             print "processing check", loop
1632             self.show_broks("update_in_checking")
1633             svc.update_in_checking()
1634             self.show_broks("fake_check")
1635             self.fake_check(svc, 2, 'BAD')
1636             self.show_broks("sched.consume_results")
1637             self.sched.consume_results()
1638             self.show_broks("sched.get_new_actions")
1639             self.sched.get_new_actions()
1640             self.show_broks("sched.get_new_broks")
1641             self.sched.get_new_broks()
1642             self.show_broks("sched.delete_zombie_checks")
1643             self.sched.delete_zombie_checks()
1644             self.show_broks("sched.delete_zombie_actions")
1645             self.sched.delete_zombie_actions()
1646             self.show_broks("sched.get_to_run_checks")
1647             checks = self.sched.get_to_run_checks(True, False)
1648             self.show_broks("sched.get_to_run_checks")
1649             actions = self.sched.get_to_run_checks(False, True)
1650             #self.show_actions()
1651             for a in actions:
1652                 a.status = 'inpoller'
1653                 a.check_time = time.time()
1654                 a.exit_status = 0
1655                 self.sched.put_results(a)
1656             #self.show_actions()
1657
1658             svc.checks_in_progress = []
1659             self.show_broks("sched.update_downtimes_and_comments")
1660             self.sched.update_downtimes_and_comments()
1661             time.sleep(5)
1662
1663         print "-------------------------------------------------"
1664         for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
1665             if re.compile('^service_').match(brok.type):
1666                 print "BROK:", brok.type
1667                 print "BROK   ", brok.data['in_checking']
1668         self.update_broker()
1669         print "-------------------------------------------------"
1670         request = 'GET services\nColumns: service_description is_executing\n'
1671         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1672         print response
1673
1674
1675
1676     def test_pnp_path(self):
1677         self.print_header()
1678         now = time.time()
1679         self.update_broker()
1680         #---------------------------------------------------------------
1681         # pnp_path is a parameter for the module
1682         # column pnpgraph_present checks if a file
1683         #  <pnp_path>/host/service.xml
1684         #  <pnp_path>/host/_HOST_.xml
1685         # exists
1686         #---------------------------------------------------------------
1687         pnp_path = self.pnp4nagios
1688         try:
1689             os.removedirs(pnp_path)
1690         except:
1691             pass
1692         else:
1693             print "there is no spool dir", pnp_path
1694
1695         request = """GET services
1696 Columns: host_name service_description pnpgraph_present
1697 OutputFormat: csv
1698 ResponseHeader: fixed16
1699 """
1700         requesth = """GET hosts
1701 Columns: host_name pnpgraph_present
1702 OutputFormat: csv
1703 ResponseHeader: fixed16
1704 """
1705         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1706         print response
1707         self.assert_(response == """200          24
1708 test_host_0;test_ok_0;0
1709 """)
1710         #self.assert_(not self.livestatus_broker.livestatus.pnp_path)
1711
1712         try:
1713             os.makedirs(pnp_path)
1714             print "there is an empty spool dir", pnp_path
1715         except:
1716             pass
1717
1718         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1719         print response
1720         self.assert_(response == """200          24
1721 test_host_0;test_ok_0;0
1722 """)
1723         self.assert_(self.livestatus_broker.livestatus.pnp_path == pnp_path + '/')
1724
1725         try:
1726             os.makedirs(pnp_path + '/test_host_0')
1727             open(pnp_path + '/test_host_0/_HOST_.xml', 'w').close()
1728             open(pnp_path + '/test_host_0/test_ok_0.xml', 'w').close()
1729             print "there is a spool dir with data", pnp_path
1730         except:
1731             pass
1732
1733         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1734         print response
1735         self.assert_(response == """200          24
1736 test_host_0;test_ok_0;1
1737 """)
1738         response, keepalive = self.livestatus_broker.livestatus.handle_request(requesth)
1739         print response
1740         goodresponse = """200          30
1741 test_router_0;0
1742 test_host_0;1
1743 """
1744         self.assert_(self.lines_equal(response, goodresponse))
1745
1746
1747     def test_thruk_action_notes_url(self):
1748         self.print_header()
1749         now = time.time()
1750         self.update_broker()
1751         request = """GET services
1752 Columns: host_name service_description action_url
1753 Filter: host_name = test_host_0
1754 Filter: service_description = test_ok_0
1755 OutputFormat: csv
1756 ResponseHeader: fixed16
1757 """
1758         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1759         self.assert_(response == """200          78
1760 test_host_0;test_ok_0;/nagios/pnp/index.php?host=$HOSTNAME$&srv=$SERVICEDESC$
1761 """)
1762
1763         request = """GET services
1764 Columns: host_name service_description action_url_expanded
1765 Filter: host_name = test_host_0
1766 Filter: service_description = test_ok_0
1767 OutputFormat: csv
1768 ResponseHeader: fixed16
1769 """
1770         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1771         self.assert_(response == """200          75
1772 test_host_0;test_ok_0;/nagios/pnp/index.php?host=test_host_0&srv=test_ok_0
1773 """)
1774
1775         request = """GET hosts
1776 Columns: host_name action_url_expanded notes_url_expanded
1777 Filter: host_name = test_host_0
1778 OutputFormat: csv
1779 ResponseHeader: fixed16
1780 """
1781         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1782         self.assert_(response == """200          85
1783 test_host_0;/nagios/pnp/index.php?host=test_host_0;/nagios/wiki/doku.php/test_host_0
1784 """)
1785
1786
1787     def test_thruk_custom_variables(self):
1788         self.print_header()
1789         now = time.time()
1790         self.update_broker()
1791         request = """GET hosts
1792 Columns: host_name custom_variable_names custom_variable_values
1793 Filter: host_name = test_host_0
1794 OutputFormat: csv
1795 ResponseHeader: fixed16
1796 """
1797         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1798         self.assert_(response == """200          42
1799 test_host_0;OSLICENSE,OSTYPE;gpl,gnulinux
1800 """)
1801
1802         request = """GET services
1803 Columns: host_name service_description custom_variable_names custom_variable_values
1804 Filter: host_name = test_host_0
1805 Filter: service_description = test_ok_0
1806 OutputFormat: csv
1807 ResponseHeader: fixed16
1808 """
1809         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1810         self.assert_(response == """200          41
1811 test_host_0;test_ok_0;CUSTNAME;custvalue
1812 """)
1813
1814
1815     def test_multisite_in_check_period(self):
1816         self.print_header()
1817         self.update_broker()
1818         # timeperiods must be manipulated in the broker, because status-broks
1819         # contain timeperiod names, not objects.
1820         lshost = self.livestatus_broker.find_host("test_host_0")
1821         now = time.time()
1822         localnow = time.localtime(now)
1823         if localnow[5] > 45:
1824             time.sleep(15)
1825         nextminute = time.localtime(time.time() + 60)
1826         tonextminute = '%s 00:00-%02d:%02d' % (['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'][nextminute[6]], nextminute[3], nextminute[4])
1827         fromnextminute = '%s %02d:%02d-23:59' % (['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'][nextminute[6]], nextminute[3], nextminute[4])
1828
1829         lshost.notification_period = Timeperiod()
1830         lshost.notification_period.resolve_daterange(lshost.notification_period.dateranges, tonextminute)
1831         lshost.check_period = Timeperiod()
1832         lshost.check_period.resolve_daterange(lshost.check_period.dateranges, fromnextminute)
1833         self.update_broker()
1834         print "now it is", time.asctime()
1835         print "notification_period is", tonextminute
1836         print "check_period is", fromnextminute
1837         request = """GET hosts
1838 Columns: host_name in_notification_period in_check_period
1839 Filter: host_name = test_host_0
1840 OutputFormat: csv
1841 ResponseHeader: fixed16
1842 """
1843
1844         # inside notification_period, outside check_period
1845         time.sleep(5)
1846         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1847         self.assert_(response == """200          16
1848 test_host_0;1;0
1849 """)
1850         time.sleep(60)
1851         # a minute later it's the other way round
1852         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1853         self.assert_(response == """200          16
1854 test_host_0;0;1
1855 """)
1856
1857
1858     def test_thruk_log_current_groups(self):
1859         self.print_header()
1860         now = time.time()
1861         b = Brok('log', {'log' : "[%lu] EXTERNAL COMMAND: [%lu] DISABLE_NOTIFICATIONS" % (now, now) })
1862         self.livestatus_broker.manage_log_brok(b)
1863         b = Brok('log', {'log' : "[%lu] EXTERNAL COMMAND: [%lu] STOP_EXECUTING_SVC_CHECKS" % (now, now) })
1864         self.livestatus_broker.manage_log_brok(b)
1865         self.update_broker()
1866         host = self.sched.hosts.find_by_name("test_host_0")
1867         host.checks_in_progress = []
1868         host.act_depend_of = [] # ignore the router
1869         router = self.sched.hosts.find_by_name("test_router_0")
1870         router.checks_in_progress = []
1871         router.act_depend_of = [] # ignore the router
1872         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1873         svc.checks_in_progress = []
1874         svc.act_depend_of = [] # no hostchecks on critical checkresults
1875         self.update_broker()
1876         self.scheduler_loop(1, [[host, 0, 'UP'], [router, 0, 'UP'], [svc, 1, 'WARNING']])
1877         self.update_broker()
1878         # select messages which are not host or service related. current_service_groups must be an empty list
1879         request = """GET log
1880 Filter: current_host_name =
1881 Filter: current_service_description =
1882 And: 2
1883 Columns: message current_service_groups
1884 """
1885         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1886         request = """GET log
1887 Filter: current_host_name =
1888 Filter: current_service_description =
1889 And: 2
1890 Columns: message current_service_groups
1891 OutputFormat: json
1892 """
1893         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1894         good_response = "[[\"[%lu] EXTERNAL COMMAND: [%lu] DISABLE_NOTIFICATIONS\",[]],[\"[%lu] EXTERNAL COMMAND: [%lu] STOP_EXECUTING_SVC_CHECKS\",[]]]\n" % (now, now, now, now)
1895         print response
1896         self.assert_(response == good_response)
1897
1898         request = """GET log
1899 Columns: time current_host_name current_service_description current_host_groups current_service_groups
1900 Filter: time >= """ + str(int(now)) + """
1901 Filter: current_host_name = test_host_0
1902 Filter: current_service_description = test_ok_0
1903 And: 2"""
1904         good_response = """1234567890;test_host_0;test_ok_0;hostgroup_01,allhosts,up;servicegroup_02,ok,servicegroup_01
1905 """
1906         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1907         # remove the timestamps
1908         good_response = ';'.join(good_response.split(';')[1:])
1909         response = ';'.join(response.split(';')[1:])
1910         print response
1911         self.assert_(self.lines_equal(response, good_response))
1912
1913
1914     def test_thruk_empty_stats(self):
1915         self.print_header()
1916         self.update_broker()
1917         # surely no host object matches with this filter
1918         # nonetheless there must be a line of output
1919         request = """GET hosts
1920 Filter: has_been_checked = 10
1921 Filter: check_type = 10
1922 Stats: sum percent_state_change
1923 Stats: min percent_state_change
1924 Stats: max percent_state_change
1925 OutputFormat: csv"""
1926
1927         good_response = """0;0;0"""
1928
1929         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1930         print response
1931         self.assert_(self.lines_equal(response, good_response))
1932
1933
1934     def test_thruk_host_parents(self):
1935         self.print_header()
1936         self.update_broker()
1937         # surely no host object matches with this filter
1938         # nonetheless there must be a line of output
1939         request = """GET hosts
1940 Columns: host_name parents
1941 OutputFormat: csv"""
1942
1943         good_response = """test_router_0;
1944 test_host_0;test_router_0
1945 """
1946
1947         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1948         print response
1949         self.assert_(self.lines_equal(response, good_response))
1950
1951
1952
1953     def test_statsgroupby(self):
1954         self.print_header()
1955         now = time.time()
1956         objlist = []
1957         for host in self.sched.hosts:
1958             objlist.append([host, 0, 'UP'])
1959         for service in self.sched.services:
1960             objlist.append([service, 0, 'OK'])
1961         self.scheduler_loop(1, objlist)
1962         self.update_broker()
1963         svc1 = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
1964         print svc1
1965         self.scheduler_loop(1, [[svc1, 1, 'W']])
1966         self.update_broker()
1967
1968         request = """GET services
1969 Filter: contacts >= test_contact
1970 Stats: state != 9999
1971 Stats: state = 0
1972 Stats: state = 1
1973 Stats: state = 2
1974 Stats: state = 3
1975 StatsGroupBy: host_name"""
1976         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1977         print response
1978         self.assert_(self.contains_line(response, 'test_host_0;1;0;1;0;0'))
1979
1980         request = """GET services
1981 Stats: state != 9999
1982 StatsGroupBy: state
1983 """
1984         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
1985         print response
1986         # does not show null-values
1987         #self.assert_(self.contains_line(response, '0;0'))
1988         self.assert_(self.contains_line(response, '1;1'))
1989         #self.assert_(self.contains_line(response, '2;0'))
1990         #self.assert_(self.contains_line(response, '3;0'))
1991
1992
1993     def test_multisite_column_groupby(self):
1994         self.print_header()
1995         now = time.time()
1996         objlist = []
1997         for host in self.sched.hosts:
1998             objlist.append([host, 0, 'UP'])
1999         for service in self.sched.services:
2000             objlist.append([service, 0, 'OK'])
2001         self.scheduler_loop(1, objlist)
2002         self.update_broker()
2003         router = self.sched.hosts.find_by_name("test_router_0")
2004         host = self.sched.hosts.find_by_name("test_host_0")
2005         svc = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
2006         host.act_depend_of = []
2007         router.act_depend_of = []
2008         self.scheduler_loop(4, [[router, 1, 'D'], [host, 1, 'D'], [svc, 1, 'W']])
2009         self.update_broker()
2010         self.scheduler_loop(1, [[router, 0, 'U'], [host, 0, 'U'], [svc, 0, 'O']])
2011         self.update_broker()
2012         self.scheduler_loop(1, [[router, 1, 'D'], [host, 0, 'U'], [svc, 2, 'C']])
2013         self.update_broker()
2014
2015         request = """GET log
2016 Columns: host_name service_description
2017 Filter: log_time >= 1292256802
2018 Filter: class = 1
2019 Stats: state = 0
2020 Stats: state = 1
2021 Stats: state = 2
2022 Stats: state = 3
2023 Stats: state != 0
2024 OutputFormat: csv
2025 Limit: 1001"""
2026         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2027         print response
2028         self.assert_(self.contains_line(response, 'test_host_0;;1;3;0;0;3'))
2029         self.assert_(self.contains_line(response, 'test_router_0;;1;4;0;0;4'))
2030         self.assert_(self.contains_line(response, 'test_host_0;test_ok_0;1;2;1;0;3'))
2031
2032
2033         # does not show null-values
2034         #self.assert_(self.contains_line(response, '0;0'))
2035         #self.assert_(self.contains_line(response, '1;1'))
2036         #self.assert_(self.contains_line(response, '2;0'))
2037         #self.assert_(self.contains_line(response, '3;0'))
2038
2039
2040
2041 class TestConfigBig(TestConfig):
2042     def setUp(self):
2043         self.setup_with_file('etc/nagios_5r_100h_2000s.cfg')
2044         Comment.id = 1
2045         self.testid = str(os.getpid() + random.randint(1, 1000))
2046         self.livelogs = 'tmp/livelogs.db' + self.testid
2047         self.pnp4nagios = 'tmp/pnp4nagios_test' + self.testid
2048         self.livestatus_broker = Livestatus_broker(modconf, '127.0.0.1', str(50000 + os.getpid()), 'live', [], self.livelogs, 365, self.pnp4nagios)
2049         self.livestatus_broker.create_queues()
2050         #self.livestatus_broker.properties = {
2051         #    'to_queue' : 0,
2052         #    'from_queue' : 0
2053         #}
2054         self.livestatus_broker.init()
2055         print "Cleaning old broks?"
2056         self.sched.fill_initial_broks()
2057         self.update_broker()
2058
2059
2060     def tearDown(self):
2061         self.stop_nagios()
2062         self.livestatus_broker.dbconn.commit()
2063         self.livestatus_broker.dbconn.close()
2064         if os.path.exists(self.livelogs):
2065             os.remove(self.livelogs)
2066         if os.path.exists(self.pnp4nagios):
2067             shutil.rmtree(self.pnp4nagios)
2068         if os.path.exists('var/nagios.log'):
2069             os.remove('var/nagios.log')
2070         if os.path.exists('var/retention.dat'):
2071             os.remove('var/retention.dat')
2072         if os.path.exists('var/status.dat'):
2073             os.remove('var/status.dat')
2074
2075
2076     def test_stats(self):
2077         self.print_header()
2078         if self.nagios_installed():
2079             self.start_nagios('5r_100h_2000s')
2080         now = time.time()
2081         objlist = []
2082         for host in self.sched.hosts:
2083             objlist.append([host, 0, 'UP'])
2084         for service in self.sched.services:
2085             objlist.append([service, 0, 'OK'])
2086         self.scheduler_loop(1, objlist)
2087         self.update_broker()
2088         svc1 = self.sched.services.find_srv_by_name_and_hostname("test_host_005", "test_ok_00")
2089         print svc1
2090         svc2 = self.sched.services.find_srv_by_name_and_hostname("test_host_005", "test_ok_15")
2091         print svc2
2092         svc3 = self.sched.services.find_srv_by_name_and_hostname("test_host_005", "test_ok_16")
2093         print svc3
2094         svc4 = self.sched.services.find_srv_by_name_and_hostname("test_host_007", "test_ok_05")
2095         print svc4
2096         svc5 = self.sched.services.find_srv_by_name_and_hostname("test_host_007", "test_ok_11")
2097         svc6 = self.sched.services.find_srv_by_name_and_hostname("test_host_025", "test_ok_01")
2098         svc7 = self.sched.services.find_srv_by_name_and_hostname("test_host_025", "test_ok_03")
2099         self.scheduler_loop(1, [[svc1, 1, 'W'], [svc2, 1, 'W'], [svc3, 1, 'W'], [svc4, 2, 'C'], [svc5, 3, 'U'], [svc6, 2, 'C'], [svc7, 2, 'C']])
2100         self.update_broker()
2101         # 1993O, 3xW, 3xC, 1xU
2102
2103         request = """GET services
2104 Filter: contacts >= test_contact
2105 Stats: state != 9999
2106 Stats: state = 0
2107 Stats: state = 1
2108 Stats: state = 2
2109 Stats: state = 3"""
2110         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2111         print 'query_6_______________\n%s\n%s\n' % (request, response)
2112         self.assert_(response == '2000;1993;3;3;1\n')
2113         if self.nagios_installed():
2114             nagresponse = self.ask_nagios(request)
2115             print nagresponse
2116             self.assert_(self.lines_equal(response, nagresponse))
2117
2118
2119     def test_statsgroupby(self):
2120         self.print_header()
2121         if self.nagios_installed():
2122             self.start_nagios('5r_100h_2000s')
2123         now = time.time()
2124         objlist = []
2125         for host in self.sched.hosts:
2126             objlist.append([host, 0, 'UP'])
2127         for service in self.sched.services:
2128             objlist.append([service, 0, 'OK'])
2129         self.scheduler_loop(1, objlist)
2130         self.update_broker()
2131         svc1 = self.sched.services.find_srv_by_name_and_hostname("test_host_005", "test_ok_00")
2132         print svc1
2133         svc2 = self.sched.services.find_srv_by_name_and_hostname("test_host_005", "test_ok_15")
2134         print svc2
2135         svc3 = self.sched.services.find_srv_by_name_and_hostname("test_host_005", "test_ok_16")
2136         print svc3
2137         svc4 = self.sched.services.find_srv_by_name_and_hostname("test_host_007", "test_ok_05")
2138         print svc4
2139         svc5 = self.sched.services.find_srv_by_name_and_hostname("test_host_007", "test_ok_11")
2140         svc6 = self.sched.services.find_srv_by_name_and_hostname("test_host_025", "test_ok_01")
2141         svc7 = self.sched.services.find_srv_by_name_and_hostname("test_host_025", "test_ok_03")
2142         self.scheduler_loop(1, [[svc1, 1, 'W'], [svc2, 1, 'W'], [svc3, 1, 'W'], [svc4, 2, 'C'], [svc5, 3, 'U'], [svc6, 2, 'C'], [svc7, 2, 'C']])
2143         self.update_broker()
2144         # 1993O, 3xW, 3xC, 1xU
2145
2146         request = 'GET services\nFilter: contacts >= test_contact\nStats: state != 9999\nStats: state = 0\nStats: state = 1\nStats: state = 2\nStats: state = 3\nStatsGroupBy: host_name'
2147         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2148         print response
2149         self.assert_(self.contains_line(response, 'test_host_005;20;17;3;0;0'))
2150         self.assert_(self.contains_line(response, 'test_host_007;20;18;0;1;1'))
2151         self.assert_(self.contains_line(response, 'test_host_025;20;18;0;2;0'))
2152         self.assert_(self.contains_line(response, 'test_host_026;20;20;0;0;0'))
2153
2154         request = """GET services
2155 Stats: state != 9999
2156 StatsGroupBy: state
2157 """
2158         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2159         print response
2160         self.assert_(self.contains_line(response, '0;1993'))
2161         self.assert_(self.contains_line(response, '1;3'))
2162         self.assert_(self.contains_line(response, '2;3'))
2163         self.assert_(self.contains_line(response, '3;1'))
2164         if self.nagios_installed():
2165             nagresponse = self.ask_nagios(request)
2166             print nagresponse
2167             self.assert_(self.lines_equal(response, nagresponse))
2168
2169
2170     def test_hostsbygroup(self):
2171         self.print_header()
2172         if self.nagios_installed():
2173             self.start_nagios('5r_100h_2000s')
2174         now = time.time()
2175         objlist = []
2176         for host in self.sched.hosts:
2177             objlist.append([host, 0, 'UP'])
2178         for service in self.sched.services:
2179             objlist.append([service, 0, 'OK'])
2180         self.scheduler_loop(1, objlist)
2181         self.update_broker()
2182         request = """GET hostsbygroup
2183 ColumnHeaders: on
2184 Columns: host_name hostgroup_name
2185 OutputFormat: csv
2186 KeepAlive: on
2187 ResponseHeader: fixed16
2188 """
2189
2190         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2191         print response
2192         if self.nagios_installed():
2193             nagresponse = self.ask_nagios(request)
2194             print nagresponse
2195             self.assert_(self.lines_equal(response, nagresponse))
2196
2197
2198     def test_servicesbyhostgroup(self):
2199         self.print_header()
2200         if self.nagios_installed():
2201             self.start_nagios('5r_100h_2000s')
2202         now = time.time()
2203         objlist = []
2204         for host in self.sched.hosts:
2205             objlist.append([host, 0, 'UP'])
2206         for service in self.sched.services:
2207             objlist.append([service, 0, 'OK'])
2208         self.scheduler_loop(1, objlist)
2209         self.update_broker()
2210         request = """GET servicesbyhostgroup
2211 Filter: host_groups >= up
2212 Stats: has_been_checked = 0
2213 Stats: state = 0
2214 Stats: has_been_checked != 0
2215 Stats: scheduled_downtime_depth = 0
2216 Stats: host_scheduled_downtime_depth = 0
2217 StatsAnd: 4
2218 Stats: state = 0
2219 Stats: scheduled_downtime_depth > 0
2220 Stats: host_scheduled_downtime_depth > 0
2221 StatsAnd: 3
2222 Stats: state = 1
2223 Stats: acknowledged = 0
2224 Stats: host_acknowledged = 0
2225 Stats: scheduled_downtime_depth = 0
2226 Stats: host_scheduled_downtime_depth = 0
2227 StatsAnd: 5
2228 Stats: state = 1
2229 Stats: acknowledged = 1
2230 Stats: host_acknowledged = 1
2231 StatsOr: 2
2232 StatsAnd: 2
2233 Stats: state = 1
2234 Stats: scheduled_downtime_depth > 0
2235 Stats: host_scheduled_downtime_depth > 0
2236 StatsOr: 2
2237 StatsAnd: 2
2238 Stats: state = 2
2239 Stats: acknowledged = 0
2240 Stats: host_acknowledged = 0
2241 Stats: scheduled_downtime_depth = 0
2242 Stats: host_scheduled_downtime_depth = 0
2243 StatsAnd: 5
2244 Stats: state = 2
2245 Stats: acknowledged = 1
2246 Stats: host_acknowledged = 1
2247 StatsOr: 2
2248 StatsAnd: 2
2249 Stats: state = 2
2250 Stats: scheduled_downtime_depth > 0
2251 Stats: host_scheduled_downtime_depth > 0
2252 StatsOr: 2
2253 StatsAnd: 2
2254 Stats: state = 3
2255 Stats: acknowledged = 0
2256 Stats: host_acknowledged = 0
2257 Stats: scheduled_downtime_depth = 0
2258 Stats: host_scheduled_downtime_depth = 0
2259 StatsAnd: 5
2260 Stats: state = 3
2261 Stats: acknowledged = 1
2262 Stats: host_acknowledged = 1
2263 StatsOr: 2
2264 StatsAnd: 2
2265 Stats: state = 3
2266 Stats: scheduled_downtime_depth > 0
2267 Stats: host_scheduled_downtime_depth > 0
2268 StatsOr: 2
2269 StatsAnd: 2
2270 StatsGroupBy: hostgroup_name
2271 OutputFormat: csv
2272 KeepAlive: on
2273 ResponseHeader: fixed16
2274 """
2275         tic = time.clock()
2276         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2277         tac = time.clock()
2278         print "livestatus duration %f" % (tac - tic)
2279         print response
2280         if self.nagios_installed():
2281             nagresponse = self.ask_nagios(request)
2282             print nagresponse
2283             self.assert_(self.lines_equal(response, nagresponse))
2284
2285         # Again, without Filter:
2286         request = """GET servicesbyhostgroup
2287 Stats: has_been_checked = 0
2288 Stats: state = 0
2289 Stats: has_been_checked != 0
2290 Stats: scheduled_downtime_depth = 0
2291 Stats: host_scheduled_downtime_depth = 0
2292 StatsAnd: 4
2293 Stats: state = 0
2294 Stats: scheduled_downtime_depth > 0
2295 Stats: host_scheduled_downtime_depth > 0
2296 StatsAnd: 3
2297 Stats: state = 1
2298 Stats: acknowledged = 0
2299 Stats: host_acknowledged = 0
2300 Stats: scheduled_downtime_depth = 0
2301 Stats: host_scheduled_downtime_depth = 0
2302 StatsAnd: 5
2303 Stats: state = 1
2304 Stats: acknowledged = 1
2305 Stats: host_acknowledged = 1
2306 StatsOr: 2
2307 StatsAnd: 2
2308 Stats: state = 1
2309 Stats: scheduled_downtime_depth > 0
2310 Stats: host_scheduled_downtime_depth > 0
2311 StatsOr: 2
2312 StatsAnd: 2
2313 Stats: state = 2
2314 Stats: acknowledged = 0
2315 Stats: host_acknowledged = 0
2316 Stats: scheduled_downtime_depth = 0
2317 Stats: host_scheduled_downtime_depth = 0
2318 StatsAnd: 5
2319 Stats: state = 2
2320 Stats: acknowledged = 1
2321 Stats: host_acknowledged = 1
2322 StatsOr: 2
2323 StatsAnd: 2
2324 Stats: state = 2
2325 Stats: scheduled_downtime_depth > 0
2326 Stats: host_scheduled_downtime_depth > 0
2327 StatsOr: 2
2328 StatsAnd: 2
2329 Stats: state = 3
2330 Stats: acknowledged = 0
2331 Stats: host_acknowledged = 0
2332 Stats: scheduled_downtime_depth = 0
2333 Stats: host_scheduled_downtime_depth = 0
2334 StatsAnd: 5
2335 Stats: state = 3
2336 Stats: acknowledged = 1
2337 Stats: host_acknowledged = 1
2338 StatsOr: 2
2339 StatsAnd: 2
2340 Stats: state = 3
2341 Stats: scheduled_downtime_depth > 0
2342 Stats: host_scheduled_downtime_depth > 0
2343 StatsOr: 2
2344 StatsAnd: 2
2345 StatsGroupBy: hostgroup_name
2346 OutputFormat: csv
2347 KeepAlive: on
2348 ResponseHeader: fixed16
2349 """
2350         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2351         print response
2352         if self.nagios_installed():
2353             nagresponse = self.ask_nagios(request)
2354             print nagresponse
2355             self.assert_(self.lines_equal(response, nagresponse))
2356
2357
2358     def test_childs(self):
2359         if self.nagios_installed():
2360             self.start_nagios('5r_100h_2000s')
2361         self.print_header()
2362         now = time.time()
2363         objlist = []
2364         for host in self.sched.hosts:
2365             objlist.append([host, 0, 'UP'])
2366         for service in self.sched.services:
2367             objlist.append([service, 0, 'OK'])
2368         self.scheduler_loop(1, objlist)
2369         self.update_broker()
2370         request = """GET hosts
2371 Columns: childs
2372 Filter: name = test_host_0
2373 OutputFormat: csv
2374 KeepAlive: on
2375 ResponseHeader: fixed16
2376 """
2377         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2378         print response
2379         if self.nagios_installed():
2380             nagresponse = self.ask_nagios(request)
2381             print "nagresponse----------------------------------------------"
2382             print nagresponse
2383             self.assert_(self.lines_equal(response, nagresponse))
2384         request = """GET hosts
2385 Columns: childs
2386 Filter: name = test_router_0
2387 OutputFormat: csv
2388 KeepAlive: on
2389 ResponseHeader: fixed16
2390 """
2391         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2392         print response
2393         if self.nagios_installed():
2394             nagresponse = self.ask_nagios(request)
2395             print "nagresponse----------------------------------------------"
2396             print nagresponse
2397             self.assert_(self.lines_equal(response, nagresponse))
2398
2399
2400     def test_thruk_servicegroup(self):
2401         self.print_header()
2402         now = time.time()
2403         self.update_broker()
2404         #---------------------------------------------------------------
2405         # get services of a certain servicegroup
2406         # test_host_0/test_ok_0 is in
2407         #   servicegroup_01,ok via service.servicegroups
2408         #   servicegroup_02 via servicegroup.members
2409         #---------------------------------------------------------------
2410         request = """GET services
2411 Columns: host_name service_description
2412 Filter: groups >= servicegroup_01
2413 OutputFormat: csv
2414 ResponseHeader: fixed16
2415 """
2416         # 400 services => 400 lines + header + empty last line
2417         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2418         print response
2419         self.assert_(len(response.split("\n")) == 402)
2420
2421         request = """GET servicegroups
2422 Columns: name members
2423 Filter: name = servicegroup_01
2424 OutputFormat: csv
2425 """
2426         # 400 services => 400 lines
2427         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2428         print response
2429         # take first line, take members column, count list elements = 400 services
2430         self.assert_(len(((response.split("\n")[0]).split(';')[1]).split(',')) == 400)
2431
2432
2433 class TestConfigComplex(TestConfig):
2434     def setUp(self):
2435         self.setup_with_file('etc/nagios_problem_impact.cfg')
2436         self.testid = str(os.getpid() + random.randint(1, 1000))
2437         self.livelogs = 'tmp/livelogs.db' + self.testid
2438         self.pnp4nagios = 'tmp/pnp4nagios_test' + self.testid
2439         self.livestatus_broker = Livestatus_broker(modconf, '127.0.0.1', str(50000 + os.getpid()), 'live', [], self.livelogs, 365, self.pnp4nagios)
2440         self.livestatus_broker.create_queues()
2441         self.livestatus_broker.init()
2442         print "Cleaning old broks?"
2443         self.sched.fill_initial_broks()
2444         self.update_broker()
2445         self.nagios_path = None
2446         self.livestatus_path = None
2447         self.nagios_config = None
2448
2449
2450     def tearDown(self):
2451         self.stop_nagios()
2452         self.livestatus_broker.dbconn.commit()
2453         self.livestatus_broker.dbconn.close()
2454         if os.path.exists(self.livelogs):
2455             os.remove(self.livelogs)
2456         if os.path.exists(self.pnp4nagios):
2457             shutil.rmtree(self.pnp4nagios)
2458
2459
2460     #  test_host_0  has parents test_router_0,test_router_1
2461     def test_thruk_parents(self):
2462         self.print_header()
2463         now = time.time()
2464         objlist = []
2465         for host in self.sched.hosts:
2466             objlist.append([host, 0, 'UP'])
2467         for service in self.sched.services:
2468             objlist.append([service, 0, 'OK'])
2469         self.scheduler_loop(1, objlist)
2470         self.update_broker()
2471         request = """GET hosts
2472 Columns: host_name parents childs
2473 OutputFormat: csv
2474 """
2475         good_response = """test_router_0;;test_host_0,test_host_1
2476 test_router_1;;test_host_0,test_host_1
2477 test_host_0;test_router_0,test_router_1;
2478 test_host_1;test_router_0,test_router_1;
2479 """
2480         response, keepalive = self.livestatus_broker.livestatus.handle_request(request)
2481         print response
2482         self.assert_(self.lines_equal(response, good_response))
2483
2484
2485
2486 if __name__ == '__main__':
2487     #import cProfile
2488     command = """unittest.main()"""
2489     unittest.main()
2490     #cProfile.runctx( command, globals(), locals(), filename="Thruk.profile" )
2491