Python haproxy_logfile.HaproxyLogFile类代码示例

    def test_haproxy_log_file_cmd_requests_per_minute(self):
        """Check that the requests per minute command reports as expected."""
        log_file = HaproxyLogFile(
            logfile='haproxy/tests/files/requests_per_minute.log',
        )
        log_file.parse_file()
        requests = log_file.cmd_requests_per_minute()

        self.assertEqual(len(requests), 5)

        self.assertEqual(
            requests[0],
            (datetime(2013, 12, 11, 11, 2), 8)
        )
        self.assertEqual(
            requests[1],
            (datetime(2013, 12, 11, 11, 3), 3)
        )
        self.assertEqual(
            requests[2],
            (datetime(2013, 12, 11, 11, 13), 5)
        )
        self.assertEqual(
            requests[3],
            (datetime(2013, 12, 11, 11, 52), 7)
        )
        self.assertEqual(
            requests[4],
            (datetime(2013, 12, 11, 12, 2), 9)
        )

    def test_haproxy_log_file_cmd_queue_peaks_no_end(self):
        """Check that the queue peaks command reports as expected when the
        last log request did not have any queue.
        """
        log_file = HaproxyLogFile(
            logfile='haproxy/tests/files/queue_2.log',
        )
        log_file.parse_file()
        peaks = log_file.cmd_queue_peaks()

        self.assertEqual(len(peaks), 3)
        self.assertEqual(peaks[0]['peak'], 4)
        self.assertEqual(peaks[0]['span'], 5)

        self.assertEqual(peaks[1]['peak'], 19)
        self.assertEqual(peaks[1]['span'], 5)

        self.assertEqual(peaks[2]['peak'], 49)
        self.assertEqual(peaks[2]['span'], 3)

        self.assertTrue(peaks[0]['first'] < peaks[1]['first'])
        self.assertTrue(peaks[1]['first'] < peaks[2]['first'])

        self.assertTrue(peaks[0]['last'] < peaks[1]['last'])
        self.assertTrue(peaks[1]['last'] < peaks[2]['last'])

 def test_haproxy_log_file_cmd_average_response_time(self):
     """Check that the average response time returns the expected output."""
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/average_response.log',
     )
     log_file.parse_file()
     data = log_file.cmd_average_response_time()
     self.assertEqual(data, 105)

 def test_haproxy_log_file_parsed(self):
     """Check that log files are parsed."""
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/small.log'
     )
     self.assertEqual(log_file.cmd_counter(), 0)
     log_file.parse_file()
     self.assertTrue(log_file.cmd_counter() > 0)

 def test_haproxy_log_file_total_lines(self):
     """Check that even if some lines are not valid, 'total_lines' counts
     all of them.
     """
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/2_ok_1_invalid.log'
     )
     log_file.parse_file()
     self.assertEqual(log_file.total_lines, 3)

def main(args):
    if show_help(args):
        return

    # show the command list
    if args['list_commands']:
        print_commands()
        # no need to process further
        return

    # show the filter list
    if args['list_filters']:
        print_filters()
        # no need to process further
        return

    # create a HaproxyLogFile instance and parse the log file
    log_file = HaproxyLogFile(
        logfile=args['log'],
    )
    log_file.parse_file()

    # apply the time frame filter
    if args['start'] is not None or args['delta'] is not None:
        start = args['start'] or ''
        delta = args['delta'] or ''
        filter_string = 'filters.filter_time_frame("{0}", "{1}")'
        filter_func = eval(filter_string.format(start, delta))

        log_file = log_file.filter(filter_func)

    # apply all other filters given
    if args['filters'] is not None:
        filter_string = 'filters.filter_{0}({1})'
        for filter_data in args['filters']:
            arg = ''
            if filter_data[1] is not None:
                arg = filter_data[1]
                arg = "'{0}'".format(arg)

            filter_func = eval(filter_string.format(filter_data[0], arg))

            log_file = log_file.filter(filter_func,
                                       reverse=args['negate_filter'])

    # run all commands
    command_string = 'log_file.cmd_{0}()'
    for command in args['commands']:
        string = 'command: {0}'.format(command)
        print(string)
        print('=' * len(string))

        result = eval(command_string.format(command))
        print(result)

    return log_file  # return the log_file object so that tests can inspect it

    def test_haproxy_log_file_cmd_counter_slow_requests(self):
        """Check that the slow requests counter command reports as expected.
        """
        log_file = HaproxyLogFile(
            logfile='haproxy/tests/files/small.log',
        )
        log_file.parse_file()
        slow_requests = log_file.cmd_counter_slow_requests()

        self.assertEqual(slow_requests, 5)

 def test_haproxy_log_file_cmd_average_response_time_no_wait(self):
     """Check that the average response time returns the expected output
     when there are connections that did not take any millisecond to reply.
     """
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/average_response_no_wait.log',
     )
     log_file.parse_file()
     data = log_file.cmd_average_response_time()
     self.assertEqual(data, 74)

    def test_haproxy_log_file_cmd_connection_type(self):
        """Check that the connection type command reports as expected."""
        log_file = HaproxyLogFile(
            logfile='haproxy/tests/files/connection.log',
        )
        log_file.parse_file()
        ssl, non_ssl = log_file.cmd_connection_type()

        self.assertEqual(ssl, 7)
        self.assertEqual(non_ssl, 5)

 def test_haproxy_log_file_cmd_print_empty(self):
     """Check that the print command prints an empty string if the log file
     is empty.
     """
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/empty.log',
     )
     log_file.parse_file()
     data = log_file.cmd_print()
     self.assertEqual('', data)

 def test_haproxy_log_file_valid_and_invalid_lines(self):
     """Check that if some log lines can not be parsed both numbers are
     correctly reported.
     """
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/2_ok_1_invalid.log'
     )
     log_file.parse_file()
     self.assertEqual(log_file.cmd_counter(), 2)
     self.assertEqual(log_file.cmd_counter_invalid(), 1)

 def test_haproxy_log_file_cmd_average_waiting_time_aborted(self):
     """Check that the average time waiting on queues returns the expected
     output when there are aborted connections.
     """
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/average_waiting_aborted.log',
     )
     log_file.parse_file()
     data = log_file.cmd_average_waiting_time()
     self.assertEqual(data, 110)

    def test_haproxy_log_file_pickle_is_recreated(self):
        """Check that a pickle file is recreated if the log file is newer
        than the pickle file."""
        filename = 'haproxy/tests/files/average_waiting_aborted.log'
        pickle_file = '{0}.pickle'.format(filename)

        # create the pickle file and get its modified time
        log_file = HaproxyLogFile(
            logfile=filename,
        )
        log_file.parse_file()
        old_pickle_time = os.path.getmtime(pickle_file)

        # any second or nth run will not change the modified time
        log_file = HaproxyLogFile(
            logfile=filename,
        )
        log_file.parse_file()
        second_old_pickle_time = os.path.getmtime(pickle_file)
        self.assertEqual(old_pickle_time, second_old_pickle_time)

        # 'update' the original log file
        sleep(1)  # os.path.getmtime has a resolution up to seconds
        os.utime(filename, None)

        # the existing pickle file is discarded and a newer one will be created
        log_file = HaproxyLogFile(
            logfile=filename,
        )
        log_file.parse_file()
        new_pickle_time = os.path.getmtime(pickle_file)

        self.assertTrue(new_pickle_time > old_pickle_time)

    def test_haproxy_log_file_cmd_print(self):
        """Check that the print command prints the valid lines."""
        log_file = HaproxyLogFile(
            logfile='haproxy/tests/files/2_ok_1_invalid.log',
        )
        log_file.parse_file()
        data = log_file.cmd_print()
        self.assertNotEqual('', data)

        lines = data.split('\n')
        self.assertEqual(len(lines), 3)

 def test_haproxy_log_file_cmd_average_waiting_time_no_wait(self):
     """Check that the average time waiting on queues returns the expected
     output when there are requests that did not wait at all (i.e.
     time_wait_queues is 0).
     """
     log_file = HaproxyLogFile(
         logfile='haproxy/tests/files/average_waiting_no_wait.log',
     )
     log_file.parse_file()
     data = log_file.cmd_average_waiting_time()
     self.assertEqual(data, 52.5)