Python Timeperiod.get_next_invalid_time_from_t方法代码示例

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_mondayweek_timeperiod_with_exclude(self):
        """
        Test monday week timeperiod with exclude

        :return: None
        """
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a simple same day
        timeperiod = Timeperiod()
        timeperiod.timeperiod_name = 'T1'
        timeperiod.resolve_daterange(timeperiod.dateranges, 'tuesday 3 16:30-24:00')
        t_next = timeperiod.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        self.assertEqual("Tue Jul 20 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # And a good one: from april (so before) to august (after), and full time.
        # But the 17 is a tuesday, but the 3 of august, so the next 3 tuesday is
        # ..... the Tue Sep 21 :) Yes, we should wait quite a lot :)
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'april 1 - august 23 00:00-24:00')
        timeperiod.exclude = [t2]
        timeperiod.cache = {}
        t_next = timeperiod.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        self.assertEqual('Tue Sep 21 16:30:00 2010', t_next)

        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        t_exclude_inv = time.asctime(time.localtime(t_exclude_inv))
        self.assertEqual('Tue Aug 24 00:00:00 2010', t_exclude_inv)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_dayweek_exclusion_timeperiod(self):
        """
        Test week day timeperiod with exclusion

        :return: None
        """
        now = time.time()
        # Get the 13 of july 2010 at 15:00, tuesday
        july_the_13 = time.mktime(time.strptime("13 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))
        print(july_the_13)

        # Now we add this timeperiod an exception
        timeperiod = Timeperiod()

        timeperiod.resolve_daterange(timeperiod.dateranges, 'monday 00:00-24:00')
        timeperiod.resolve_daterange(timeperiod.dateranges, 'tuesday 00:00-24:00')
        timeperiod.resolve_daterange(timeperiod.dateranges, 'wednesday 00:00-24:00')

        t2 = Timeperiod()
        t2.timeperiod_name = ''
        t2.resolve_daterange(t2.dateranges, 'tuesday 00:00-24:00')
        timeperiod.exclude = [t2]

        t_next = timeperiod.get_next_valid_time_from_t(july_the_13)
        t_next = time.asctime(time.localtime(t_next))
        print("T next", t_next)
        self.assertEqual("Wed Jul 14 00:00:00 2010", t_next)

        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))
        t_inv = timeperiod.get_next_invalid_time_from_t(july_the_12)
        t_inv = time.asctime(time.localtime(t_inv))
        self.assertEqual('Tue Jul 13 00:00:00 2010', t_inv)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_dayweek_timeperiod_with_exclude(self):
        self.print_header()
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a simple same day
        t = Timeperiod()
        t.timeperiod_name = 'T1'
        t.resolve_daterange(t.dateranges, 'tuesday 2 16:30-24:00')
        t_next = t.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print "T next", t_next
        self.assertEqual("Tue Jul 13 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'tuesday 00:00-23:58')
        t.exclude = [t2]
        # We are a bad boy: first time period want a tuesday
        # but exclude do not want it until 23:58. So next is 58 + 1second :)
        t.cache = {}
        t_next = t.get_next_valid_time_from_t(july_the_12)
        t_exclude = t2.get_next_valid_time_from_t(july_the_12)
        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)

        print "T next raw", t_next
        t_next = time.asctime(time.localtime(t_next))
        print "TOTO T next", t_next

        self.assertEqual('Tue Jul 13 23:58:01 2010', t_next)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_simple_with_multiple_time_multiple_days(self):
        """
        Test timeperiod with multiple daterange on multiple days:
          * monday 00:00-07:00
          * monday 21:30-24:00
          * tuesday 00:00-07:00
          * tuesday 21:30-24:00

        :return: None
        """
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))
        print(july_the_12)

        # Then a simple same day
        timeperiod = Timeperiod()
        print("Cheking validity for", time.asctime(time.localtime(july_the_12)))
        timeperiod.resolve_daterange(timeperiod.dateranges, 'monday 00:00-07:00,21:30-24:00')
        timeperiod.resolve_daterange(timeperiod.dateranges, 'tuesday 00:00-07:00,21:30-24:00')
        t_next = timeperiod.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print("RES:", t_next)
        self.assertEqual("Mon Jul 12 21:30:00 2010", t_next)

        # what about the next invalid?
        t_next_inv = timeperiod.get_next_invalid_time_from_t(july_the_12)
        t_next_inv = time.asctime(time.localtime(t_next_inv))
        print("RES:", t_next_inv)
        self.assertEqual("Mon Jul 12 15:00:00 2010", t_next_inv)

        # what about a valid time and ask next invalid? Like at 22:00h?
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 22:00:00", "%d %b %Y %H:%M:%S"))
        t_next_inv = timeperiod.get_next_invalid_time_from_t(july_the_12)
        t_next_inv = time.asctime(time.localtime(t_next_inv))
        print("RES:", t_next_inv) #, t.is_time_valid(july_the_12)
        self.assertEqual("Tue Jul 13 07:00:01 2010", t_next_inv)

        # Now ask about at 00:00 time?
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 00:00:00", "%d %b %Y %H:%M:%S"))
        print("Cheking validity for", time.asctime(time.localtime(july_the_12)))
        # Then a simple same day
        t_next = timeperiod.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print("Next?", t_next)
        self.assertEqual("Mon Jul 12 00:00:00 2010", t_next)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_get_invalid_time(self):
        """
        Test get next invalid time

        :return: None
        """
        timeperiod = Timeperiod()
        timeperiod.resolve_daterange(timeperiod.dateranges, 'monday 00:00-24:00')
        first_nov = int(time.mktime(time.strptime("1 Nov 2010 00:00:00", "%d %b %Y %H:%M:%S")))
        print(first_nov)
        end = timeperiod.get_next_invalid_time_from_t(first_nov)
        end = time.asctime(time.localtime(end))
        self.assertEqual("Tue Nov  2 00:00:00 2010", end)

        first_nov = int(time.mktime(time.strptime("2 Nov 2010 00:00:00", "%d %b %Y %H:%M:%S")))
        print(first_nov)
        end = timeperiod.get_next_invalid_time_from_t(first_nov)
        end = time.asctime(time.localtime(end))
        self.assertEqual("Tue Nov  2 00:00:00 2010", end)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_get_invalid_time_with_exclude(self):
        """
        Test get next invalid time with exclude

        :return: None
        """
        timeperiod = Timeperiod()
        timeperiod.resolve_daterange(timeperiod.dateranges, 'monday 00:00-24:00')

        t2 = Timeperiod()
        t2.resolve_daterange(t2.dateranges, 'monday 08:30-21:00')
        timeperiod.exclude = [t2]

        first_nov = int(time.mktime(time.strptime("1 Nov 2010 00:00:00", "%d %b %Y %H:%M:%S")))
        print(first_nov)
        end = timeperiod.get_next_invalid_time_from_t(first_nov)
        end = time.asctime(time.localtime(end))
        self.assertEqual("Mon Nov  1 08:30:00 2010", end)

        second_nov = int(time.mktime(time.strptime("2 Nov 2010 00:00:00", "%d %b %Y %H:%M:%S")))
        print(second_nov)
        end = timeperiod.get_next_invalid_time_from_t(second_nov)
        end = time.asctime(time.localtime(end))
        self.assertEqual("Tue Nov  2 00:00:00 2010", end)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_next_invalid_day(self):
        self.print_header()

        # Get the 13 of july 2010 at 15:00, tuesday
        july_the_13 = time.mktime(time.strptime("13 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))
        print july_the_13

        t = Timeperiod()
        t.timeperiod_name = 'test_next_invalid_day'
        t.resolve_daterange(t.dateranges, 'tuesday 00:00-24:00')
        t.exclude = []

        t_next_invalid = t.get_next_invalid_time_from_t(july_the_13)
        t_next_invalid = time.asctime(time.localtime(t_next_invalid))
        print "T next invalid", t_next_invalid
        self.assertEqual("Wed Jul 14 00:00:01 2010", t_next_invalid)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_funky_mondayweek_timeperiod_with_exclude_and_multiple_daterange(self):
        self.print_header()
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a funny daterange
        print "Testing daterange", 'tuesday -1 - monday 1  16:30-24:00'
        t = Timeperiod()
        t.timeperiod_name = 'T1'
        t.resolve_daterange(t.dateranges, 'tuesday -1 - monday 1  16:30-24:00')
        t_next = t.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print "Next without exclude", t_next
        self.assertEqual("Tue Jul 27 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # And a good one: from april (so before so agust (after), and full time.
        # But the 27 is nw not possible? So what next? Add a month!
        # But maybe it's not enoutgth? :)
        # The withoutthe 2nd exclude, it's the Tues Aug 31, btu it's inside
        # saturday -1 - monday 1 because saturday -1 is the 28 august, so no.
        # in september saturday -1 is the 25, and tuesday -1 is 28, so still no
        # A month again! So now tuesday -1 is 26 and saturday -1 is 30. So ok
        # for this one! that was quite long isn't it? And funky! :)
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'april 1 - august 16 00:00-24:00')
        # Oups, I add a inner daterange ;)
        t2.resolve_daterange(t2.dateranges, 'saturday -1 - monday 1  16:00-24:00')
        t.exclude = [t2]
        # We are a bad boy: first time period want a tuesday
        # but exclude do not want it until 23:58. So next is 59 :)
        t.cache = {}
        t_next = t.get_next_valid_time_from_t(july_the_12)
        #print "Check from", time.asctime(time.localtime(july_the_12))
        #t_exclude = t2.get_next_valid_time_from_t(july_the_12)
        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        #print "T2 next valid", time.asctime(time.localtime(t_exclude))
        print "Next invalid T2", time.asctime(time.localtime(t_exclude_inv))

        print "T next raw", t_next
        print "T next?", time.asctime(time.localtime(t_next))
        t_next = time.asctime(time.localtime(t_next))

        self.assertEqual('Tue Oct 26 16:30:00 2010', t_next)
        print "Finish this Funky test :)"

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_mondayweek_timeperiod_with_exclude_and_multiple_daterange(self):
        """
        Test monday week timeperiod with exclude multiple dateranges

        :return: None
        """
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a funny daterange
        print("Testing daterange", 'tuesday -1 - monday 1  16:30-24:00')
        timeperiod = Timeperiod()
        timeperiod.timeperiod_name = 'T1'
        timeperiod.resolve_daterange(timeperiod.dateranges, 'tuesday -1 - monday 1  16:30-24:00')
        t_next = timeperiod.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print("Next without exclude", t_next)
        self.assertEqual("Tue Jul 27 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # And a good one: from april (so before) to august (after), and full time.
        # But the 27 is nw not possible? So what next? Add a month!
        # But maybe it's not enough? :)
        # The without the 2nd exclude, it's the Tues Aug 31, but it's inside
        # saturday -1 - monday 1 because saturday -1 is the 28 august, so no.
        # in september saturday -1 is the 25, and tuesday -1 is 28, so still no
        # A month again! So now tuesday -1 is 26 and saturday -1 is 30. So ok
        # for this one! that was quite long isn't it?
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'april 1 - august 16 00:00-24:00')
        t2.resolve_daterange(t2.dateranges, 'saturday -1 - monday 1  16:00-24:00')
        timeperiod.exclude = [t2]
        timeperiod.cache = {}
        t_next = timeperiod.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        self.assertEqual('Tue Oct 26 16:30:00 2010', t_next)

        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        t_exclude_inv = time.asctime(time.localtime(t_exclude_inv))
        self.assertEqual('Tue Aug 17 00:00:00 2010', t_exclude_inv)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_mondayweek_timeperiod_with_exclude_bis(self):
        """
        Test monday weeb timeperiod with exclude, version 2 :D

        :return: None
        """
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a funny daterange
        print("Testing daterange", 'tuesday -1 - monday 1  16:30-24:00')
        timerange = Timeperiod()
        timerange.timeperiod_name = 'T1'
        timerange.resolve_daterange(timerange.dateranges, 'tuesday -1 - monday 1  16:30-24:00')
        t_next = timerange.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print("Next without exclude", t_next)
        self.assertEqual("Tue Jul 27 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # And a good one: from april (so before) to august (after), and full time.
        # But the 27 is now not possible? So what next? Add a month!
        # last tuesday of august, the 31 :)
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'april 1 - august 16 00:00-24:00')
        timerange.exclude = [t2]
        timerange.cache = {}
        t_next = timerange.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        self.assertEqual('Tue Aug 31 16:30:00 2010', t_next)

        t_exclude = t2.get_next_valid_time_from_t(july_the_12)
        t_exclude = time.asctime(time.localtime(t_exclude))
        self.assertEqual('Mon Jul 12 15:00:00 2010', t_exclude)

        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        t_exclude_inv = time.asctime(time.localtime(t_exclude_inv))
        self.assertEqual('Tue Aug 17 00:00:00 2010', t_exclude_inv)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_mondayweek_timeperiod_with_exclude_bis(self):
        self.print_header()
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a funny daterange
        print "Testing daterange", 'tuesday -1 - monday 1  16:30-24:00'
        t = Timeperiod()
        t.timeperiod_name = 'T1'
        t.resolve_daterange(t.dateranges, 'tuesday -1 - monday 1  16:30-24:00')
        t_next = t.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print "Next without exclude", t_next
        self.assertEqual("Tue Jul 27 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # And a good one: from april (so before so agust (after), and full time.
        # But the 27 is nw not possible? So what next? Add a month!
        # last tuesday of august, the 31 :)
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'april 1 - august 16 00:00-24:00')
        #print t2.__dict__
        t.exclude = [t2]
        # We are a bad boy: first time period want a tuesday
        # but exclude do not want it until 23:58. So next is 59 :)
        t.cache = {}
        t_next = t.get_next_valid_time_from_t(july_the_12)
        #print "Check from", time.asctime(time.localtime(july_the_12))
        #t_exclude = t2.get_next_valid_time_from_t(july_the_12)
        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        #print "T2 next valid", time.asctime(time.localtime(t_exclude))
        print "Next invalid T2", time.asctime(time.localtime(t_exclude_inv))

        print "T next raw JEAN2", t_next
        print "T next?", time.asctime(time.localtime(t_next))
        t_next = time.asctime(time.localtime(t_next))

        self.assertEqual('Tue Aug 31 16:30:00 2010', t_next)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_get_invalid_when_timeperiod_24x7(self):
        """
        Test get the next invalid time when timeperiod 24x7

        :return:
        """
        now = time.time()
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Now look for the never case
        tp_all = Timeperiod()
        tp_all.resolve_daterange(tp_all.dateranges, 'monday 00:00-24:00')
        tp_all.resolve_daterange(tp_all.dateranges, 'tuesday 00:00-24:00')
        tp_all.resolve_daterange(tp_all.dateranges, 'wednesday 00:00-24:00')
        tp_all.resolve_daterange(tp_all.dateranges, 'thursday 00:00-24:00')
        tp_all.resolve_daterange(tp_all.dateranges, 'friday 00:00-24:00')
        tp_all.resolve_daterange(tp_all.dateranges, 'saturday 00:00-24:00')
        tp_all.resolve_daterange(tp_all.dateranges, 'sunday 00:00-24:00')
        t_next_inv = tp_all.get_next_invalid_time_from_t(july_the_12)
        t_next_inv = time.asctime(time.localtime(t_next_inv))
        print("RES:", t_next_inv) #, t.is_time_valid(july_the_12)
        self.assertEqual('Tue Jul 19 00:00:00 2011', t_next_inv)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_monweekday_timeperiod_with_exclude(self):
        self.print_header()
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a funny daterange
        print "Testing daterange", 'tuesday -1 july - monday 1 august  16:30-24:00'
        t = Timeperiod()
        t.timeperiod_name = 'T1'
        t.resolve_daterange(t.dateranges, 'tuesday -1 july - monday 1 september  16:30-24:00')
        t_next = t.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        print "Next without exclude", t_next
        self.assertEqual("Tue Jul 27 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # and from april (before) to august monday 3 (monday 16 august),
        # so Jul 17 is no more possible. So just after it, Tue 17
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'thursday 1 april - monday 3 august 00:00-24:00')
        print t2.dateranges[0].__dict__
        t.exclude = [t2]
        # We are a bad boy: first time period want a tuesday
        # but exclude do not want it until 23:58. So next is 59 :)
        t.cache = {}
        t_next = t.get_next_valid_time_from_t(july_the_12)
        #print "Check from", time.asctime(time.localtime(july_the_12))
        #t_exclude = t2.get_next_valid_time_from_t(july_the_12)
        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        #print "T2 next valid", time.asctime(time.localtime(t_exclude))
        print "Next invalid T2", time.asctime(time.localtime(t_exclude_inv))

        print "T next raw", t_next
        print "T next?", time.asctime(time.localtime(t_next))
        t_next = time.asctime(time.localtime(t_next))

        self.assertEqual('Tue Aug 17 16:30:00 2010', t_next)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_mondayweek_timeperiod_with_exclude(self):
        self.print_header()
        now = time.time()
        # Get the 12 of july 2010 at 15:00, monday
        july_the_12 = time.mktime(time.strptime("12 Jul 2010 15:00:00", "%d %b %Y %H:%M:%S"))

        # Then a simple same day
        t = Timeperiod()
        t.timeperiod_name = 'T1'
        t.resolve_daterange(t.dateranges, 'tuesday 2 16:30-24:00')
        t_next = t.get_next_valid_time_from_t(july_the_12)
        t_next = time.asctime(time.localtime(t_next))
        self.assertEqual("Tue Jul 13 16:30:00 2010", t_next)

        # Now we add this timeperiod an exception
        # And a good one: from april (so before so agust (after), and full time.
        # But the 17 is a tuesday, but the 3 of august, so the next 2 tuesday is
        # ..... the Tue Sep 14 :) Yes, we should wait quite a lot :)
        t2 = Timeperiod()
        t2.timeperiod_name = 'T2'
        t2.resolve_daterange(t2.dateranges, 'april 1 - august 16 00:00-24:00')
        #print t2.__dict__
        t.exclude = [t2]
        # We are a bad boy: first time period want a tuesday
        # but exclude do not want it until 23:58. So next is 59 :)
        t.cache = {}
        t_next = t.get_next_valid_time_from_t(july_the_12)
        #print "Check from", time.asctime(time.localtime(july_the_12))
        #t_exclude = t2.get_next_valid_time_from_t(july_the_12)
        t_exclude_inv = t2.get_next_invalid_time_from_t(july_the_12)
        #print "T2 next valid", time.asctime(time.localtime(t_exclude))
        print "Next invalid T2", time.asctime(time.localtime(t_exclude_inv))

        print "T next raw JEAN", t_next
        print "T next?", time.asctime(time.localtime(t_next))
        t_next = time.asctime(time.localtime(t_next))

        self.assertEqual('Tue Sep 14 16:30:00 2010', t_next)

# 需要导入模块: from alignak.objects.timeperiod import Timeperiod [as 别名]
# 或者: from alignak.objects.timeperiod.Timeperiod import get_next_invalid_time_from_t [as 别名]
    def test_check_enter_downtime(self):
        test_router_0 = self.sched.hosts.find_by_name("test_router_0")
        test_host_0 = self.sched.hosts.find_by_name("test_host_0")
        test_nobody = self.sched.hosts.find_by_name("test_nobody")

        svc1 = self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0")
        svc2 = self.sched.services.find_srv_by_name_and_hostname("test_router_0", "test_ok_0")
        svc3 = self.sched.services.find_srv_by_name_and_hostname("test_nobody", "test_ok_0")
        # we want to focus on only one maintenance
        test_router_0.maintenance_period = None
        test_host_0.maintenance_period = None
        test_nobody.maintenance_period = None
        svc1.maintenance_period = None
        svc2.maintenance_period = None

        # be sure we have some time before a new minute begins.
        # otherwise we get a race condition and a failed test here.
        now = time.time()
        x = time.gmtime(now)
        while x.tm_sec < 50:
            time.sleep(1)
            now = time.time()
            x = time.gmtime(now)

        now = time.time()
        print "now it is", time.asctime(time.localtime(now))
        nowday = time.strftime("%A", time.localtime(now + 60)).lower()
        soonstart = time.strftime("%H:%M", time.localtime(now + 60))
        soonend = time.strftime("%H:%M", time.localtime(now + 180))

        range = "%s %s-%s" % (nowday, soonstart, soonend)
        print "range is ", range
        t = Timeperiod()
        t.timeperiod_name = ''
        t.resolve_daterange(t.dateranges, range)
        t_next = t.get_next_valid_time_from_t(now)
        print "planned start", time.asctime(time.localtime(t_next))
        t_next = t.get_next_invalid_time_from_t(t_next + 1)
        print "planned stop ", time.asctime(time.localtime(t_next))
        svc3.maintenance_period = t

        self.assertFalse(svc3.in_maintenance)
        #
        # now let the scheduler run and wait until the maintenance period begins
        # it is now 10 seconds before the full minute. run for 30 seconds
        # in 1-second-intervals. this should be enough to trigger the downtime
        # in 10 seconds from now the downtime starts
        print "scheduler_loop start", time.asctime()
        self.scheduler_loop(30, [[svc3, 0, 'OK']], do_sleep=True, sleep_time=1)
        print "scheduler_loop end  ", time.asctime()

        self.assertTrue(hasattr(svc3, 'in_maintenance'))
        self.assertEqual(1, len(self.sched.downtimes))
        try:
            print "........................................."
            print self.sched.downtimes[1]
            print "downtime starts", time.asctime(self.sched.downtimes[1].start_time)
            print "downtime ends  ", time.asctime(self.sched.downtimes[1].end_time)
        except Exception:
            print "looks like there is no downtime"
            pass
        self.assertEqual(1, len(svc3.downtimes))
        self.assertIn(svc3.downtimes[0], self.sched.downtimes.values())
        self.assertTrue(svc3.in_scheduled_downtime)
        self.assertTrue(svc3.downtimes[0].fixed)
        self.assertTrue(svc3.downtimes[0].is_in_effect)
        self.assertFalse(svc3.downtimes[0].can_be_deleted)
        self.assertEqual(svc3.downtimes[0]._id, svc3.in_maintenance)

        #
        # now the downtime should expire...
        # we already have 20 seconds (after 10 seconds of startup).
        # the downtime is 120 seconds long.
        # run the remaining 100 seconds plus 5 seconds just to be sure
        self.scheduler_loop(105, [[svc3, 0, 'OK']], do_sleep=True, sleep_time=1)

        self.assertEqual(0, len(self.sched.downtimes))
        self.assertEqual(0, len(svc3.downtimes))
        self.assertFalse(svc3.in_scheduled_downtime)
        self.assertIs(None, svc3.in_maintenance)