test/test_passive_pollers.py

   1 #!/usr/bin/env python2.6
   2 #Copyright (C) 2009-2010 :
   3 #    Gabes Jean, naparuba@gmail.com
   4 #    Gerhard Lausser, Gerhard.Lausser@consol.de
   5 #
   6 #This file is part of Shinken.
   7 #
   8 #Shinken is free software: you can redistribute it and/or modify
   9 #it under the terms of the GNU Affero General Public License as published by
  10 #the Free Software Foundation, either version 3 of the License, or
  11 #(at your option) any later version.
  12 #
  13 #Shinken is distributed in the hope that it will be useful,
  14 #but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 #GNU Affero General Public License for more details.
  17 #
  18 #You should have received a copy of the GNU Affero General Public License
  19 #along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 #
  22 # This file is used to test reading and processing of config files
  23 #
  24
  25 #It's ugly I know....
  26 from shinken_test import *
  27
  28
  29 class GoodArbiter(ArbiterLink):
  30     # To lie about satellites
  31     def ping(self):
  32         print "Dummy OK for", self.get_name()
  33         self.set_alive()
  34
  35     def have_conf(self, i):
  36         return True
  37
  38     def do_not_run(self):
  39         pass
  40
  41
  42 class GoodScheduler(SchedulerLink):
  43     # To lie about satellites
  44     def ping(self):
  45         print "Dummy OK for", self.get_name()
  46         self.set_alive()
  47
  48     def have_conf(self, i):
  49         return True
  50
  51     def put_conf(self, conf):
  52         return True
  53
  54
  55 class BadScheduler(SchedulerLink):
  56     def ping(self):
  57         print "Dummy bad ping", self.get_name()
  58         self.add_failed_check_attempt()
  59
  60     def have_conf(self, i):
  61         return False
  62
  63 class GoodPoller(PollerLink):
  64     # To lie about satellites
  65     def ping(self):
  66         print "Dummy OK for", self.get_name()
  67         self.set_alive()
  68
  69     def put_conf(self, conf):
  70         return True
  71
  72
  73 class BadPoller(PollerLink):
  74     def ping(self):
  75         print "Dummy bad ping", self.get_name()
  76         self.add_failed_check_attempt()
  77
  78 class GoodReactionner(ReactionnerLink):
  79     # To lie about satellites
  80     def ping(self):
  81         print "Dummy OK for", self.get_name()
  82         self.set_alive()
  83
  84     def put_conf(self, conf):
  85         return True
  86
  87 class BadReactionner(ReactionnerLink):
  88     def ping(self):
  89         print "Dummy bad ping", self.get_name()
  90         self.add_failed_check_attempt()
  91
  92 class GoodBroker(BrokerLink):
  93     # To lie about satellites
  94     def ping(self):
  95         print "Dummy OK for", self.get_name()
  96         self.set_alive()
  97
  98     def put_conf(self, conf):
  99         return True
 100
 101 class BadBroker(BrokerLink):
 102     def ping(self):
 103         print "Dummy bad ping", self.get_name()
 104         self.add_failed_check_attempt()
 105
 106
 107 class TestPassivePoller(ShinkenTest):
 108     #Uncomment this is you want to use a specific configuration
 109     #for your test
 110     def setUp(self):
 111         self.setup_with_file('etc/nagios_passive_pollers.cfg')
 112
 113
 114     #Change ME :)
 115     def test_simple_passive_pollers(self):
 116         print "The dispatcher", self.dispatcher
 117         # dummy for the arbiter
 118         for a in self.conf.arbiterlinks:
 119             a.__class__ = GoodArbiter
 120         print "Preparing schedulers"
 121         scheduler1 = self.conf.schedulerlinks.find_by_name('scheduler-all-1')
 122         self.assert_(scheduler1 is not None)
 123         scheduler1.__class__ = GoodScheduler
 124         scheduler2 = self.conf.schedulerlinks.find_by_name('scheduler-all-2')
 125         self.assert_(scheduler2 is not None)
 126         scheduler2.__class__ = BadScheduler
 127
 128         # Poller 1 is normal, 2 and 3 are passives
 129         print "Preparing pollers"
 130         poller1 = self.conf.pollers.find_by_name('poller-all-1')
 131         self.assert_(poller1 is not None)
 132         poller1.__class__ = GoodPoller
 133         print poller1.__dict__
 134         self.assert_(poller1.passive == False)
 135         poller2 = self.conf.pollers.find_by_name('poller-all-2')
 136         self.assert_(poller2 is not None)
 137         poller2.__class__ = GoodPoller
 138         self.assert_(poller2.passive == True)
 139         poller3 = self.conf.pollers.find_by_name('poller-all-3')
 140         self.assert_(poller3 is not None)
 141         poller3.__class__ = GoodPoller
 142         self.assert_(poller3.passive == True)
 143
 144         print "Preparing reactionners"
 145         reactionner1 = self.conf.reactionners.find_by_name('reactionner-all-1')
 146         self.assert_(reactionner1 is not None)
 147         reactionner1.__class__ = GoodReactionner
 148         reactionner2 = self.conf.reactionners.find_by_name('reactionner-all-2')
 149         self.assert_(reactionner2 is not None)
 150         reactionner2.__class__ = BadReactionner
 151
 152         print "Preparing brokers"
 153         broker1 = self.conf.brokers.find_by_name('broker-all-1')
 154         self.assert_(broker1 is not None)
 155         broker1.__class__ = GoodBroker
 156         broker2 = self.conf.brokers.find_by_name('broker-all-2')
 157         self.assert_(broker2 is not None)
 158         broker2.__class__ = BadBroker
 159
 160         # Ping all elements. Should have 1 as OK, 2 as
 161         # one bad attempt (3 max)
 162         self.dispatcher.check_alive()
 163
 164         # Check good values
 165         self.assert_(scheduler1.alive == True)
 166         self.assert_(scheduler1.attempt == 0)
 167         self.assert_(scheduler1.reachable == True)
 168         # still alive, just unreach
 169         self.assert_(scheduler2.alive == True)
 170         self.assert_(scheduler2.attempt == 1)
 171         self.assert_(scheduler2.reachable == False)
 172
 173         #and others satellites too
 174         self.assert_(poller1.alive == True)
 175         self.assert_(poller1.attempt == 0)
 176         self.assert_(poller1.reachable == True)
 177         # still alive, just unreach
 178         self.assert_(poller2.alive == True)
 179         self.assert_(poller2.attempt == 0)
 180         self.assert_(poller2.reachable == True)
 181
 182         #and others satellites too
 183         self.assert_(reactionner1.alive == True)
 184         self.assert_(reactionner1.attempt == 0)
 185         self.assert_(reactionner1.reachable == True)
 186         # still alive, just unreach
 187         self.assert_(reactionner2.alive == True)
 188         self.assert_(reactionner2.attempt == 1)
 189         self.assert_(reactionner2.reachable == False)
 190
 191         #and others satellites too
 192         self.assert_(broker1.alive == True)
 193         self.assert_(broker1.attempt == 0)
 194         self.assert_(broker1.reachable == True)
 195         # still alive, just unreach
 196         self.assert_(broker2.alive == True)
 197         self.assert_(broker2.attempt == 1)
 198         self.assert_(broker2.reachable == False)
 199
 200         ### Now add another attempt, still alive, but attemp=2/3
 201         self.dispatcher.check_alive()
 202
 203         # Check good values
 204         self.assert_(scheduler1.alive == True)
 205         self.assert_(scheduler1.attempt == 0)
 206         self.assert_(scheduler1.reachable == True)
 207         # still alive, just unreach
 208         self.assert_(scheduler2.alive == True)
 209         self.assert_(scheduler2.attempt == 2)
 210         self.assert_(scheduler2.reachable == False)
 211
 212         #and others satellites too
 213         self.assert_(poller1.alive == True)
 214         self.assert_(poller1.attempt == 0)
 215         self.assert_(poller1.reachable == True)
 216         # still alive, just unreach
 217         self.assert_(poller2.alive == True)
 218         self.assert_(poller2.attempt == 0)
 219         self.assert_(poller2.reachable == True)
 220
 221         #and others satellites too
 222         self.assert_(reactionner1.alive == True)
 223         self.assert_(reactionner1.attempt == 0)
 224         self.assert_(reactionner1.reachable == True)
 225         # still alive, just unreach
 226         self.assert_(reactionner2.alive == True)
 227         self.assert_(reactionner2.attempt == 2)
 228         self.assert_(reactionner2.reachable == False)
 229
 230         #and others satellites too
 231         self.assert_(broker1.alive == True)
 232         self.assert_(broker1.attempt == 0)
 233         self.assert_(broker1.reachable == True)
 234         # still alive, just unreach
 235         self.assert_(broker2.alive == True)
 236         self.assert_(broker2.attempt == 2)
 237         self.assert_(broker2.reachable == False)
 238
 239         ### Now we get BAD, We go DEAD for N2 !
 240         self.dispatcher.check_alive()
 241
 242         # Check good values
 243         self.assert_(scheduler1.alive == True)
 244         self.assert_(scheduler1.attempt == 0)
 245         self.assert_(scheduler1.reachable == True)
 246         # still alive, just unreach
 247         self.assert_(scheduler2.alive == False)
 248         self.assert_(scheduler2.attempt == 3)
 249         self.assert_(scheduler2.reachable == False)
 250
 251         #and others satellites too
 252         self.assert_(poller1.alive == True)
 253         self.assert_(poller1.attempt == 0)
 254         self.assert_(poller1.reachable == True)
 255         # still alive, just unreach
 256         self.assert_(poller2.alive == True)
 257         self.assert_(poller2.attempt == 0)
 258         self.assert_(poller2.reachable == True)
 259
 260         #and others satellites too
 261         self.assert_(reactionner1.alive == True)
 262         self.assert_(reactionner1.attempt == 0)
 263         self.assert_(reactionner1.reachable == True)
 264         # still alive, just unreach
 265         self.assert_(reactionner2.alive == False)
 266         self.assert_(reactionner2.attempt == 3)
 267         self.assert_(reactionner2.reachable == False)
 268
 269         #and others satellites too
 270         self.assert_(broker1.alive == True)
 271         self.assert_(broker1.attempt == 0)
 272         self.assert_(broker1.reachable == True)
 273         # still alive, just unreach
 274         self.assert_(broker2.alive == False)
 275         self.assert_(broker2.attempt == 3)
 276         self.assert_(broker2.reachable == False)
 277
 278         # Now we check how we should dispatch confs
 279         self.dispatcher.check_dispatch()
 280         # the conf should not be in a good shape
 281         self.assert_(self.dispatcher.dispatch_ok == False)
 282
 283         # Now we really dispatch them!
 284         self.dispatcher.dispatch()
 285         self.assert_(self.any_log_match('Dispatch OK of for conf in scheduler scheduler-all-1'))
 286         self.assert_(self.any_log_match('Dispatch OK of for configuration 0 to reactionner reactionner-all-1'))
 287         self.assert_(self.any_log_match('Dispatch OK of for configuration 0 to poller poller-all-1'))
 288         self.assert_(self.any_log_match('Dispatch OK of for configuration 0 to broker broker-all-1'))
 289         self.clear_logs()
 290
 291         # And look if we really dispatch conf as we should
 292         for r in self.conf.realms:
 293             for cfg in r.confs.values():
 294                 self.assert_(cfg.is_assigned == True)
 295                 self.assert_(cfg.assigned_to == scheduler1)
 296
 297
 298 if __name__ == '__main__':
 299     unittest.main()
 300