示例#1
0
    def test_seek_after_reading_to_end(self):
        with tempfile.TemporaryDirectory() as tmpdirname:
            logging.info('created temporary directory "%s"', tmpdirname)
            filebase = tmpdirname + '/mylog-'
            sample_lines = []
            for f in sorted(SAMPLE_DATA_2):
                create_file(filebase + f, SAMPLE_DATA_2[f])
                sample_lines.extend(SAMPLE_DATA_2[f])
            START_TIMESTAMP = get_msec_timestamp(sample_lines[0])
            END_TIMESTAMP = get_msec_timestamp(sample_lines[-1])

            reader = LogfileReader(filebase)
            while reader.read() is not None:
                pass
            self.assertEqual(END_TIMESTAMP, reader.seek_time(0, 'current'))
            self.assertEqual(None, reader.read())
            self.assertEqual(END_TIMESTAMP, reader.seek_time(0, 'end'))
            self.assertEqual(None, reader.read())
            self.assertEqual(END_TIMESTAMP - 1000,
                             reader.seek_time(-1000, 'current'))
            self.assertEqual(sample_lines[9], reader.read())
            while reader.read() is not None:
                pass
            self.assertEqual(END_TIMESTAMP - 1000,
                             reader.seek_time(-1000, 'end'))
            self.assertEqual(sample_lines[9], reader.read())
示例#2
0
    def test_basic_seek(self):
        with tempfile.TemporaryDirectory() as tmpdirname:
            logging.info('created temporary directory "%s"', tmpdirname)
            filebase = tmpdirname + '/mylog-'
            sample_lines = []
            for f in sorted(SAMPLE_DATA_2):
                create_file(filebase + f, SAMPLE_DATA_2[f])
                sample_lines.extend(SAMPLE_DATA_2[f])
            START_TIMESTAMP = get_msec_timestamp(sample_lines[0])
            END_TIMESTAMP = get_msec_timestamp(sample_lines[-1])

            reader = LogfileReader(filebase)
            self.assertEqual(START_TIMESTAMP, reader.seek_time(0, 'start'))
            self.assertEqual(sample_lines[0], reader.read())
            self.assertEqual(START_TIMESTAMP + 1000,
                             reader.seek_time(1000, 'start'))
            self.assertEqual(sample_lines[4], reader.read())
            self.assertEqual(sample_lines[5], reader.read())
            self.assertEqual(END_TIMESTAMP, reader.seek_time(0, 'end'))
            self.assertEqual(None, reader.read())
示例#3
0
    def test_seek_current(self):
        with tempfile.TemporaryDirectory() as tmpdirname:
            logging.info('created temporary directory "%s"', tmpdirname)
            filebase = tmpdirname + '/mylog-'
            sample_lines = []
            for f in sorted(SAMPLE_DATA_2):
                create_file(filebase + f, SAMPLE_DATA_2[f])
                sample_lines.extend(SAMPLE_DATA_2[f])
            START_TIMESTAMP = get_msec_timestamp(sample_lines[0])
            END_TIMESTAMP = get_msec_timestamp(sample_lines[-1])

            reader = LogfileReader(filebase)
            self.assertEqual(START_TIMESTAMP, reader.seek_time(0, 'current'))
            self.assertEqual(START_TIMESTAMP + 1000,
                             reader.seek_time(1000, 'current'))

            # the first record with t >= START_TIMESTAMP + 1000 (= 1509840000441.672)
            # is sample_lines[4]
            timestamp_of_expected_next_record = get_msec_timestamp(
                sample_lines[4])  # 1509840000460.595
            self.assertEqual(timestamp_of_expected_next_record,
                             reader.seek_time(0, 'current'))
            self.assertEqual(timestamp_of_expected_next_record - 500,
                             reader.seek_time(-500, 'current'))

            # now the expected next record is sample_lines[3], since it's the first one with
            # t > timestamp_of_expected_next_record - 500 (= 1509839999960.595)
            self.assertEqual(sample_lines[3], reader.read())
            self.assertEqual(sample_lines[4], reader.read())

            # now seek to a time later than the last timestamp: check that the returned
            # time is the requested time, and that a subsequent read() returns None
            timestamp_of_expected_next_record = get_msec_timestamp(
                sample_lines[5])
            self.assertEqual(timestamp_of_expected_next_record + 10000,
                             reader.seek_time(10000, 'current'))
            self.assertEqual(None, reader.read())

            # check that 'current' time is now END_TIMESTAMP (= 1509840002486.203)
            self.assertEqual(END_TIMESTAMP, reader.seek_time(0, 'current'))

            # go back one second (to 1509840001486.203)
            # next record should be sample_lines[9] (t = 1509840001726.024)
            self.assertEqual(END_TIMESTAMP - 1000,
                             reader.seek_time(-1000, 'current'))
            self.assertEqual(sample_lines[9], reader.read())