Пример #1
0
    def write_config(self, config_path):
        if self.__raw_config:
            rendered_config = self.__raw_config
        else:
            rendered_config = ConfigRenderer(self.__syslog_ng_config).get_rendered_config()
        logger.info("Generated syslog-ng config\n{}\n".format(rendered_config))

        f = File(config_path)
        with f.open('w+') as config_file:
            config_file.write(rendered_config)
Пример #2
0
    def write(self, content, rate=None):
        loggen_input_file_path = Path(tc_parameters.WORKING_DIR, "loggen_input_{}.txt".format(get_unique_id()))

        loggen_input_file = File(loggen_input_file_path)
        loggen_input_file.open(mode="w")
        loggen_input_file.write(content)
        loggen_input_file.close()

        Loggen().start(self.__ip, self.__port, read_file=str(loggen_input_file_path), dont_parse=True, permanent=True, rate=rate, **self.__transport.value)
Пример #3
0
    def get_log(self):
        f = File(self.snmptrapd_log)
        f.open("r")

        log = f.read()

        f.close()

        return log
def test_pp_tls_passthrough(config, syslog_ng, port_allocator, loggen,
                            testcase_parameters):
    server_key_path = copy_shared_file(testcase_parameters, "server.key")
    server_cert_path = copy_shared_file(testcase_parameters, "server.crt")

    network_source = config.create_network_source(
        ip="localhost",
        port=port_allocator(),
        transport='"proxied-tls-passthrough"',
        flags="no-parse",
        tls={
            "key-file": server_key_path,
            "cert-file": server_cert_path,
            "peer-verify": '"optional-untrusted"',
        },
    )

    file_destination = config.create_file_destination(file_name="output.log",
                                                      template=TEMPLATE)
    config.create_logpath(statements=[network_source, file_destination])

    syslog_ng.start(config)

    loggen_input_file_path = Path(
        tc_parameters.WORKING_DIR,
        "loggen_input_{}.txt".format(get_unique_id()))
    loggen_input_file = File(loggen_input_file_path)
    loggen_input_file.open(mode="w")
    loggen_input_file.write(INPUT_MESSAGES)
    loggen_input_file.close()

    loggen.start(
        network_source.options["ip"],
        network_source.options["port"],
        number=NUMBER_OF_MESSAGES,
        use_ssl=True,
        proxied_tls_passthrough=True,
        read_file=str(loggen_input_file_path),
        dont_parse=True,
        proxy_src_ip="1.1.1.1",
        proxy_dst_ip="2.2.2.2",
        proxy_src_port="3333",
        proxy_dst_port="4444",
    )

    wait_until_true(
        lambda: loggen.get_sent_message_count() == NUMBER_OF_MESSAGES)
    assert file_destination.read_log() == EXPECTED_MESSAGES
Пример #5
0
    def get_traps(self, counter):
        trap_list = []

        f = File(self.snmptrapd_log)
        f.open("r")

        while True:
            trap_line = f.wait_for_lines([self.TRAP_LOG_PREFIX])[0]
            res = re.match('({})(.*)'.format(self.TRAP_LOG_PREFIX), trap_line)
            if (res):
                trap_list.extend(res.group(2).rstrip().split("\t"))
            if len(trap_list) == counter:
                break

        f.close()

        return sorted(trap_list)
Пример #6
0
 def __init__(self, file_path):
     self.__readable_file = File(file_path)
     self.__writeable_file = File(file_path)
Пример #7
0
class FileIO():
    def __init__(self, file_path):
        self.__readable_file = File(file_path)
        self.__writeable_file = File(file_path)

    def read_number_of_lines(self, counter):
        if not self.__readable_file.is_opened():
            if not self.__readable_file.wait_for_creation():
                raise Exception("{} was not created in time.".format(
                    self.__readable_file.path))
            self.__readable_file.open("r")

        return self.__readable_file.wait_for_number_of_lines(counter)

    def read_until_lines(self, lines):
        if not self.__readable_file.is_opened():
            if not self.__readable_file.wait_for_creation():
                raise Exception("{} was not created in time.".format(
                    self.__readable_file.path))
            self.__readable_file.open("r")

        return self.__readable_file.wait_for_lines(lines)

    def write(self, content):
        if not self.__writeable_file.is_opened():
            self.__writeable_file.open("a+")

        self.__writeable_file.write(content)
Пример #8
0
 def __read_all_from_stderr_file(self):
     stderr_file_from_the_beginning = File(self.__stderr_path)
     stderr_file_from_the_beginning.open("r")
     stderr = stderr_file_from_the_beginning.read()
     stderr_file_from_the_beginning.close()
     return stderr
Пример #9
0
 def __init__(self, instance_paths):
     self.__stderr_path = instance_paths.get_stderr_path()
     self.__stderr_file = File(self.__stderr_path)
Пример #10
0
class ConsoleLogReader(object):
    def __init__(self, instance_paths):
        self.__stderr_path = instance_paths.get_stderr_path()
        self.__stderr_file = File(self.__stderr_path)

    def wait_for_start_message(self):
        syslog_ng_start_message = ["syslog-ng starting up;"]
        return self.wait_for_messages_in_console_log(syslog_ng_start_message)

    def wait_for_stop_message(self):
        syslog_ng_stop_message = ["syslog-ng shutting down"]
        return self.wait_for_messages_in_console_log(syslog_ng_stop_message)

    def wait_for_reload_message(self):
        syslog_ng_reload_messages = [
            "New configuration initialized",
            "Configuration reload request received, reloading configuration",
            "Configuration reload finished",
        ]
        return self.wait_for_messages_in_console_log(syslog_ng_reload_messages)

    def wait_for_message_in_console_log(self, expected_message):
        return self.wait_for_messages_in_console_log(self, [expected_message])

    def wait_for_messages_in_console_log(self, expected_messages):
        if not self.__stderr_file.is_opened():
            self.__stderr_file.wait_for_creation()
            self.__stderr_file.open("r")
        return self.__stderr_file.wait_for_lines(expected_messages, timeout=5)

    def check_for_unexpected_messages(self, unexpected_messages=None):
        unexpected_patterns = ["Plugin module not found", "assertion"]
        if unexpected_messages is not None:
            unexpected_patterns.extend(unexpected_messages)

        stderr = self.__read_all_from_stderr_file()

        for unexpected_pattern in unexpected_patterns:
            for console_log_message in stderr.split("\n"):
                if unexpected_pattern in console_log_message:
                    logger.error("Found unexpected message in console log: {}".format(console_log_message))
                    raise Exception("Unexpected error log in console", console_log_message)

    def dump_stderr(self, last_n_lines=10):
        stderr = self.__read_all_from_stderr_file()
        logger.error("\n".join(stderr.split("\n")[-last_n_lines:]))

    def __read_all_from_stderr_file(self):
        stderr_file_from_the_beginning = File(self.__stderr_path)
        stderr_file_from_the_beginning.open("r")
        stderr = stderr_file_from_the_beginning.read()
        stderr_file_from_the_beginning.close()
        return stderr

    @staticmethod
    def handle_valgrind_log(valgrind_log_path):
        with open(valgrind_log_path, "r") as valgrind_log:
            valgrind_content = valgrind_log.read()
            assert "Invalid read" not in valgrind_content
            assert "Invalid write" not in valgrind_content
            assert "blocks are definitely lost in loss record" not in valgrind_content
            assert "Uninitialised value was created by a heap allocation" not in valgrind_content
Пример #11
0
def prepare_std_outputs(stdout_path, stderr_path):
    stdout = File(stdout_path)
    stderr = File(stderr_path)
    return stdout, stderr