[lttng-tools.git] / tests / utils / lttngtest / environment.py

#!/usr/bin/env python3
#
# Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
#
# SPDX-License-Identifier: GPL-2.0-only
#

from types import FrameType
from typing import Callable, Iterator, Optional, Tuple, List, Generator
import sys
import pathlib
import signal
import subprocess
import shlex
import shutil
import os
import queue
import tempfile
from . import logger
import time
import threading
import contextlib


class TemporaryDirectory:
    def __init__(self, prefix):
        # type: (str) -> None
        self._directory_path = tempfile.mkdtemp(prefix=prefix)

    def __del__(self):
        shutil.rmtree(self._directory_path, ignore_errors=True)

    @property
    def path(self):
        # type: () -> pathlib.Path
        return pathlib.Path(self._directory_path)


class _SignalWaitQueue:
    """
    Utility class useful to wait for a signal before proceeding.

    Simply register the `signal` method as the handler for the signal you are
    interested in and call `wait_for_signal` to wait for its reception.

    Registering a signal:
        signal.signal(signal.SIGWHATEVER, queue.signal)

    Waiting for the signal:
        queue.wait_for_signal()
    """

    def __init__(self):
        self._queue = queue.Queue()  # type: queue.Queue

    def signal(
        self,
        signal_number,
        frame,  # type: Optional[FrameType]
    ):
        self._queue.put_nowait(signal_number)

    def wait_for_signal(self):
        self._queue.get(block=True)

    @contextlib.contextmanager
    def intercept_signal(self, signal_number):
        # type: (int) -> Generator[None, None, None]
        original_handler = signal.getsignal(signal_number)
        signal.signal(signal_number, self.signal)
        try:
            yield
        except:
            # Restore the original signal handler and forward the exception.
            raise
        finally:
            signal.signal(signal_number, original_handler)


class WaitTraceTestApplication:
    """
    Create an application that waits before tracing. This allows a test to
    launch an application, get its PID, and get it to start tracing when it
    has completed its setup.
    """

    def __init__(
        self,
        binary_path,  # type: pathlib.Path
        event_count,  # type: int
        environment,  # type: Environment
        wait_time_between_events_us=0,  # type: int
    ):
        self._environment = environment  # type: Environment
        if event_count % 5:
            # The test application currently produces 5 different events per iteration.
            raise ValueError("event count must be a multiple of 5")
        self._iteration_count = int(event_count / 5)  # type: int
        # File that the application will wait to see before tracing its events.
        self._app_start_tracing_file_path = pathlib.Path(
            tempfile.mktemp(
                prefix="app_",
                suffix="_start_tracing",
                dir=self._compat_open_path(environment.lttng_home_location),
            )
        )
        self._has_returned = False

        test_app_env = os.environ.copy()
        test_app_env["LTTNG_HOME"] = str(environment.lttng_home_location)
        # Make sure the app is blocked until it is properly registered to
        # the session daemon.
        test_app_env["LTTNG_UST_REGISTER_TIMEOUT"] = "-1"

        # File that the application will create to indicate it has completed its initialization.
        app_ready_file_path = tempfile.mktemp(
            prefix="app_",
            suffix="_ready",
            dir=self._compat_open_path(environment.lttng_home_location),
        )  # type: str

        test_app_args = [str(binary_path)]
        test_app_args.extend(
            shlex.split(
                "--iter {iteration_count} --create-in-main {app_ready_file_path} --wait-before-first-event {app_start_tracing_file_path} --wait {wait_time_between_events_us}".format(
                    iteration_count=self._iteration_count,
                    app_ready_file_path=app_ready_file_path,
                    app_start_tracing_file_path=self._app_start_tracing_file_path,
                    wait_time_between_events_us=wait_time_between_events_us,
                )
            )
        )

        self._process = subprocess.Popen(
            test_app_args,
            env=test_app_env,
        )  # type: subprocess.Popen

        # Wait for the application to create the file indicating it has fully
        # initialized. Make sure the app hasn't crashed in order to not wait
        # forever.
        while True:
            if os.path.exists(app_ready_file_path):
                break

            if self._process.poll() is not None:
                # Application has unexepectedly returned.
                raise RuntimeError(
                    "Test application has unexepectedly returned during its initialization with return code `{return_code}`".format(
                        return_code=self._process.returncode
                    )
                )

            time.sleep(0.1)

    def trace(self):
        # type: () -> None
        if self._process.poll() is not None:
            # Application has unexepectedly returned.
            raise RuntimeError(
                "Test application has unexepectedly before tracing with return code `{return_code}`".format(
                    return_code=self._process.returncode
                )
            )
        open(self._compat_open_path(self._app_start_tracing_file_path), mode="x")

    def wait_for_exit(self):
        # type: () -> None
        if self._process.wait() != 0:
            raise RuntimeError(
                "Test application has exit with return code `{return_code}`".format(
                    return_code=self._process.returncode
                )
            )
        self._has_returned = True

    @property
    def vpid(self):
        # type: () -> int
        return self._process.pid

    @staticmethod
    def _compat_open_path(path):
        # type: (pathlib.Path) -> pathlib.Path | str
        """
        The builtin open() in python >= 3.6 expects a path-like object while
        prior versions expect a string or bytes object. Return the correct type
        based on the presence of the "__fspath__" attribute specified in PEP-519.
        """
        if hasattr(path, "__fspath__"):
            return path
        else:
            return str(path)

    def __del__(self):
        if not self._has_returned:
            # This is potentially racy if the pid has been recycled. However,
            # we can't use pidfd_open since it is only available in python >= 3.9.
            self._process.kill()
            self._process.wait()


class TraceTestApplication:
    """
    Create an application that emits events as soon as it is launched. In most
    scenarios, it is preferable to use a WaitTraceTestApplication.
    """

    def __init__(self, binary_path, environment):
        # type: (pathlib.Path, Environment)
        self._environment = environment  # type: Environment
        self._has_returned = False

        test_app_env = os.environ.copy()
        test_app_env["LTTNG_HOME"] = str(environment.lttng_home_location)
        # Make sure the app is blocked until it is properly registered to
        # the session daemon.
        test_app_env["LTTNG_UST_REGISTER_TIMEOUT"] = "-1"

        test_app_args = [str(binary_path)]

        self._process = subprocess.Popen(
            test_app_args, env=test_app_env
        )  # type: subprocess.Popen

    def wait_for_exit(self):
        # type: () -> None
        if self._process.wait() != 0:
            raise RuntimeError(
                "Test application has exit with return code `{return_code}`".format(
                    return_code=self._process.returncode
                )
            )
        self._has_returned = True

    def __del__(self):
        if not self._has_returned:
            # This is potentially racy if the pid has been recycled. However,
            # we can't use pidfd_open since it is only available in python >= 3.9.
            self._process.kill()
            self._process.wait()


class ProcessOutputConsumer(threading.Thread, logger._Logger):
    def __init__(
        self,
        process,  # type: subprocess.Popen
        name,  # type: str
        log,  # type: Callable[[str], None]
    ):
        threading.Thread.__init__(self)
        self._prefix = name
        logger._Logger.__init__(self, log)
        self._process = process

    def run(self):
        # type: () -> None
        while self._process.poll() is None:
            assert self._process.stdout
            line = self._process.stdout.readline().decode("utf-8").replace("\n", "")
            if len(line) != 0:
                self._log("{prefix}: {line}".format(prefix=self._prefix, line=line))


# Generate a temporary environment in which to execute a test.
class _Environment(logger._Logger):
    def __init__(
        self,
        with_sessiond,  # type: bool
        log=None,  # type: Optional[Callable[[str], None]]
    ):
        super().__init__(log)
        signal.signal(signal.SIGTERM, self._handle_termination_signal)
        signal.signal(signal.SIGINT, self._handle_termination_signal)

        # Assumes the project's hierarchy to this file is:
        # tests/utils/python/this_file
        self._project_root = (
            pathlib.Path(__file__).absolute().parents[3]
        )  # type: pathlib.Path
        self._lttng_home = TemporaryDirectory(
            "lttng_test_env_home"
        )  # type: Optional[TemporaryDirectory]

        self._sessiond = (
            self._launch_lttng_sessiond() if with_sessiond else None
        )  # type: Optional[subprocess.Popen[bytes]]

    @property
    def lttng_home_location(self):
        # type: () -> pathlib.Path
        if self._lttng_home is None:
            raise RuntimeError("Attempt to access LTTng home after clean-up")
        return self._lttng_home.path

    @property
    def lttng_client_path(self):
        # type: () -> pathlib.Path
        return self._project_root / "src" / "bin" / "lttng" / "lttng"

    def create_temporary_directory(self, prefix=None):
        # type: (Optional[str]) -> pathlib.Path
        # Simply return a path that is contained within LTTNG_HOME; it will
        # be destroyed when the temporary home goes out of scope.
        assert self._lttng_home
        return pathlib.Path(
            tempfile.mkdtemp(
                prefix="tmp" if prefix is None else prefix,
                dir=str(self._lttng_home.path),
            )
        )

    # Unpack a list of environment variables from a string
    # such as "HELLO=is_it ME='/you/are/looking/for'"
    @staticmethod
    def _unpack_env_vars(env_vars_string):
        # type: (str) -> List[Tuple[str, str]]
        unpacked_vars = []
        for var in shlex.split(env_vars_string):
            equal_position = var.find("=")
            # Must have an equal sign and not end with an equal sign
            if equal_position == -1 or equal_position == len(var) - 1:
                raise ValueError(
                    "Invalid sessiond environment variable: `{}`".format(var)
                )

            var_name = var[0:equal_position]
            var_value = var[equal_position + 1 :]
            # Unquote any paths
            var_value = var_value.replace("'", "")
            var_value = var_value.replace('"', "")
            unpacked_vars.append((var_name, var_value))

        return unpacked_vars

    def _launch_lttng_sessiond(self):
        # type: () -> Optional[subprocess.Popen]
        is_64bits_host = sys.maxsize > 2**32

        sessiond_path = (
            self._project_root / "src" / "bin" / "lttng-sessiond" / "lttng-sessiond"
        )
        consumerd_path_option_name = "--consumerd{bitness}-path".format(
            bitness="64" if is_64bits_host else "32"
        )
        consumerd_path = (
            self._project_root / "src" / "bin" / "lttng-consumerd" / "lttng-consumerd"
        )

        no_sessiond_var = os.environ.get("TEST_NO_SESSIOND")
        if no_sessiond_var and no_sessiond_var == "1":
            # Run test without a session daemon; the user probably
            # intends to run one under gdb for example.
            return None

        # Setup the session daemon's environment
        sessiond_env_vars = os.environ.get("LTTNG_SESSIOND_ENV_VARS")
        sessiond_env = os.environ.copy()
        if sessiond_env_vars:
            self._log("Additional lttng-sessiond environment variables:")
            additional_vars = self._unpack_env_vars(sessiond_env_vars)
            for var_name, var_value in additional_vars:
                self._log("  {name}={value}".format(name=var_name, value=var_value))
                sessiond_env[var_name] = var_value

        sessiond_env["LTTNG_SESSION_CONFIG_XSD_PATH"] = str(
            self._project_root / "src" / "common"
        )

        assert self._lttng_home is not None
        sessiond_env["LTTNG_HOME"] = str(self._lttng_home.path)

        wait_queue = _SignalWaitQueue()
        with wait_queue.intercept_signal(signal.SIGUSR1):
            self._log(
                "Launching session daemon with LTTNG_HOME=`{home_dir}`".format(
                    home_dir=str(self._lttng_home.path)
                )
            )
            process = subprocess.Popen(
                [
                    str(sessiond_path),
                    consumerd_path_option_name,
                    str(consumerd_path),
                    "--sig-parent",
                ],
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                env=sessiond_env,
            )

            if self._logging_function:
                self._sessiond_output_consumer = ProcessOutputConsumer(
                    process, "lttng-sessiond", self._logging_function
                )  # type: Optional[ProcessOutputConsumer]
                self._sessiond_output_consumer.daemon = True
                self._sessiond_output_consumer.start()

            # Wait for SIGUSR1, indicating the sessiond is ready to proceed
            wait_queue.wait_for_signal()

        return process

    def _handle_termination_signal(self, signal_number, frame):
        # type: (int, Optional[FrameType]) -> None
        self._log(
            "Killed by {signal_name} signal, cleaning-up".format(
                signal_name=signal.strsignal(signal_number)
            )
        )
        self._cleanup()

    def launch_wait_trace_test_application(self, event_count):
        # type: (int) -> WaitTraceTestApplication
        """
        Launch an application that will wait before tracing `event_count` events.
        """
        return WaitTraceTestApplication(
            self._project_root
            / "tests"
            / "utils"
            / "testapp"
            / "gen-ust-nevents"
            / "gen-ust-nevents",
            event_count,
            self,
        )

    def launch_trace_test_constructor_application(self):
        # type () -> TraceTestApplication
        """
        Launch an application that will trace from within constructors.
        """
        return TraceTestApplication(
            self._project_root
            / "tests"
            / "utils"
            / "testapp"
            / "gen-ust-events-constructor"
            / "gen-ust-events-constructor",
            self,
        )

    # Clean-up managed processes
    def _cleanup(self):
        # type: () -> None
        if self._sessiond and self._sessiond.poll() is None:
            # The session daemon is alive; kill it.
            self._log(
                "Killing session daemon (pid = {sessiond_pid})".format(
                    sessiond_pid=self._sessiond.pid
                )
            )

            self._sessiond.terminate()
            self._sessiond.wait()
            if self._sessiond_output_consumer:
                self._sessiond_output_consumer.join()
                self._sessiond_output_consumer = None

            self._log("Session daemon killed")
            self._sessiond = None

        self._lttng_home = None

    def __del__(self):
        self._cleanup()


@contextlib.contextmanager
def test_environment(with_sessiond, log=None):
    # type: (bool, Optional[Callable[[str], None]]) -> Iterator[_Environment]
    env = _Environment(with_sessiond, log)
    try:
        yield env
    finally:
        env._cleanup()
Commit	Line	Data
ef945e4d JG	1	#!/usr/bin/env python3
	2	#
	3	# Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	4	#
	5	# SPDX-License-Identifier: GPL-2.0-only
	6	#
	7
	8	from types import FrameType
0ac0f70e	9	from typing import Callable, Iterator, Optional, Tuple, List, Generator
ef945e4d JG	10	import sys
	11	import pathlib
	12	import signal
	13	import subprocess
	14	import shlex
	15	import shutil
	16	import os
	17	import queue
	18	import tempfile
	19	from . import logger
	20	import time
	21	import threading
	22	import contextlib
	23
	24
	25	class TemporaryDirectory:
ce8470c9 MJ	26	def __init__(self, prefix):
ce8470c9 MJ	27	# type: (str) -> None
ef945e4d JG	28	self._directory_path = tempfile.mkdtemp(prefix=prefix)
	29
	30	def __del__(self):
	31	shutil.rmtree(self._directory_path, ignore_errors=True)
	32
	33	@property
ce8470c9 MJ	34	def path(self):
ce8470c9 MJ	35	# type: () -> pathlib.Path
ef945e4d JG	36	return pathlib.Path(self._directory_path)
	37
	38
	39	class _SignalWaitQueue:
	40	"""
	41	Utility class useful to wait for a signal before proceeding.
	42
	43	Simply register the `signal` method as the handler for the signal you are
	44	interested in and call `wait_for_signal` to wait for its reception.
	45
	46	Registering a signal:
	47	signal.signal(signal.SIGWHATEVER, queue.signal)
	48
	49	Waiting for the signal:
	50	queue.wait_for_signal()
	51	"""
	52
	53	def __init__(self):
ce8470c9	54	self._queue = queue.Queue() # type: queue.Queue
ef945e4d	55
ce8470c9 MJ	56	def signal(
	57	self,
	58	signal_number,
	59	frame, # type: Optional[FrameType]
	60	):
ef945e4d JG	61	self._queue.put_nowait(signal_number)
	62
	63	def wait_for_signal(self):
	64	self._queue.get(block=True)
	65
0ac0f70e JG	66	@contextlib.contextmanager
	67	def intercept_signal(self, signal_number):
	68	# type: (int) -> Generator[None, None, None]
	69	original_handler = signal.getsignal(signal_number)
	70	signal.signal(signal_number, self.signal)
	71	try:
	72	yield
	73	except:
	74	# Restore the original signal handler and forward the exception.
	75	raise
	76	finally:
	77	signal.signal(signal_number, original_handler)
	78
ef945e4d JG	79
	80	class WaitTraceTestApplication:
	81	"""
	82	Create an application that waits before tracing. This allows a test to
	83	launch an application, get its PID, and get it to start tracing when it
	84	has completed its setup.
	85	"""
	86
	87	def __init__(
	88	self,
ce8470c9 MJ	89	binary_path, # type: pathlib.Path
	90	event_count, # type: int
	91	environment, # type: Environment
	92	wait_time_between_events_us=0, # type: int
ef945e4d	93	):
ce8470c9	94	self._environment = environment # type: Environment
ef945e4d JG	95	if event_count % 5:
	96	# The test application currently produces 5 different events per iteration.
	97	raise ValueError("event count must be a multiple of 5")
ce8470c9	98	self._iteration_count = int(event_count / 5) # type: int
ef945e4d	99	# File that the application will wait to see before tracing its events.
ce8470c9	100	self._app_start_tracing_file_path = pathlib.Path(
ef945e4d JG	101	tempfile.mktemp(
	102	prefix="app_",
	103	suffix="_start_tracing",
2d2198ca	104	dir=self._compat_open_path(environment.lttng_home_location),
ef945e4d JG	105	)
	106	)
	107	self._has_returned = False
	108
	109	test_app_env = os.environ.copy()
	110	test_app_env["LTTNG_HOME"] = str(environment.lttng_home_location)
	111	# Make sure the app is blocked until it is properly registered to
	112	# the session daemon.
	113	test_app_env["LTTNG_UST_REGISTER_TIMEOUT"] = "-1"
	114
	115	# File that the application will create to indicate it has completed its initialization.
8466f071	116	app_ready_file_path = tempfile.mktemp(
2d2198ca MJ	117	prefix="app_",
	118	suffix="_ready",
	119	dir=self._compat_open_path(environment.lttng_home_location),
ce8470c9	120	) # type: str
ef945e4d JG	121
	122	test_app_args = [str(binary_path)]
	123	test_app_args.extend(
	124	shlex.split(
	125	"--iter {iteration_count} --create-in-main {app_ready_file_path} --wait-before-first-event {app_start_tracing_file_path} --wait {wait_time_between_events_us}".format(
	126	iteration_count=self._iteration_count,
	127	app_ready_file_path=app_ready_file_path,
	128	app_start_tracing_file_path=self._app_start_tracing_file_path,
	129	wait_time_between_events_us=wait_time_between_events_us,
	130	)
	131	)
	132	)
	133
ce8470c9	134	self._process = subprocess.Popen(
ef945e4d JG	135	test_app_args,
ef945e4d JG	136	env=test_app_env,
ce8470c9	137	) # type: subprocess.Popen
ef945e4d JG	138
	139	# Wait for the application to create the file indicating it has fully
	140	# initialized. Make sure the app hasn't crashed in order to not wait
	141	# forever.
	142	while True:
	143	if os.path.exists(app_ready_file_path):
	144	break
	145
	146	if self._process.poll() is not None:
	147	# Application has unexepectedly returned.
	148	raise RuntimeError(
	149	"Test application has unexepectedly returned during its initialization with return code `{return_code}`".format(
	150	return_code=self._process.returncode
	151	)
	152	)
	153
	154	time.sleep(0.1)
	155
ce8470c9 MJ	156	def trace(self):
ce8470c9 MJ	157	# type: () -> None
ef945e4d JG	158	if self._process.poll() is not None:
	159	# Application has unexepectedly returned.
	160	raise RuntimeError(
	161	"Test application has unexepectedly before tracing with return code `{return_code}`".format(
	162	return_code=self._process.returncode
	163	)
	164	)
2d2198ca	165	open(self._compat_open_path(self._app_start_tracing_file_path), mode="x")
ef945e4d	166
ce8470c9 MJ	167	def wait_for_exit(self):
ce8470c9 MJ	168	# type: () -> None
ef945e4d JG	169	if self._process.wait() != 0:
	170	raise RuntimeError(
	171	"Test application has exit with return code `{return_code}`".format(
	172	return_code=self._process.returncode
	173	)
	174	)
	175	self._has_returned = True
	176
	177	@property
ce8470c9 MJ	178	def vpid(self):
ce8470c9 MJ	179	# type: () -> int
ef945e4d JG	180	return self._process.pid
ef945e4d JG	181
2d2198ca MJ	182	@staticmethod
2d2198ca MJ	183	def _compat_open_path(path):
ce8470c9	184	# type: (pathlib.Path) -> pathlib.Path \| str
2d2198ca MJ	185	"""
	186	The builtin open() in python >= 3.6 expects a path-like object while
	187	prior versions expect a string or bytes object. Return the correct type
	188	based on the presence of the "__fspath__" attribute specified in PEP-519.
	189	"""
	190	if hasattr(path, "__fspath__"):
	191	return path
	192	else:
	193	return str(path)
	194
ef945e4d JG	195	def __del__(self):
	196	if not self._has_returned:
	197	# This is potentially racy if the pid has been recycled. However,
	198	# we can't use pidfd_open since it is only available in python >= 3.9.
	199	self._process.kill()
	200	self._process.wait()
	201
	202
da1e97c9 MD	203	class TraceTestApplication:
da1e97c9 MD	204	"""
e88109fc JG	205	Create an application that emits events as soon as it is launched. In most
e88109fc JG	206	scenarios, it is preferable to use a WaitTraceTestApplication.
da1e97c9 MD	207	"""
da1e97c9 MD	208
873d3601 MJ	209	def __init__(self, binary_path, environment):
	210	# type: (pathlib.Path, Environment)
	211	self._environment = environment # type: Environment
da1e97c9 MD	212	self._has_returned = False
	213
	214	test_app_env = os.environ.copy()
	215	test_app_env["LTTNG_HOME"] = str(environment.lttng_home_location)
	216	# Make sure the app is blocked until it is properly registered to
	217	# the session daemon.
	218	test_app_env["LTTNG_UST_REGISTER_TIMEOUT"] = "-1"
	219
	220	test_app_args = [str(binary_path)]
	221
47ddc6e5	222	self._process = subprocess.Popen(
da1e97c9	223	test_app_args, env=test_app_env
47ddc6e5	224	) # type: subprocess.Popen
da1e97c9	225
873d3601 MJ	226	def wait_for_exit(self):
873d3601 MJ	227	# type: () -> None
da1e97c9 MD	228	if self._process.wait() != 0:
	229	raise RuntimeError(
	230	"Test application has exit with return code `{return_code}`".format(
	231	return_code=self._process.returncode
	232	)
	233	)
	234	self._has_returned = True
	235
	236	def __del__(self):
	237	if not self._has_returned:
	238	# This is potentially racy if the pid has been recycled. However,
	239	# we can't use pidfd_open since it is only available in python >= 3.9.
	240	self._process.kill()
	241	self._process.wait()
	242
	243
ef945e4d JG	244	class ProcessOutputConsumer(threading.Thread, logger._Logger):
ef945e4d JG	245	def __init__(
ce8470c9 MJ	246	self,
	247	process, # type: subprocess.Popen
	248	name, # type: str
	249	log, # type: Callable[[str], None]
ef945e4d JG	250	):
	251	threading.Thread.__init__(self)
	252	self._prefix = name
	253	logger._Logger.__init__(self, log)
	254	self._process = process
	255
ce8470c9 MJ	256	def run(self):
ce8470c9 MJ	257	# type: () -> None
ef945e4d JG	258	while self._process.poll() is None:
	259	assert self._process.stdout
	260	line = self._process.stdout.readline().decode("utf-8").replace("\n", "")
	261	if len(line) != 0:
	262	self._log("{prefix}: {line}".format(prefix=self._prefix, line=line))
	263
	264
	265	# Generate a temporary environment in which to execute a test.
	266	class _Environment(logger._Logger):
	267	def __init__(
ce8470c9 MJ	268	self,
	269	with_sessiond, # type: bool
	270	log=None, # type: Optional[Callable[[str], None]]
ef945e4d JG	271	):
	272	super().__init__(log)
	273	signal.signal(signal.SIGTERM, self._handle_termination_signal)
	274	signal.signal(signal.SIGINT, self._handle_termination_signal)
	275
	276	# Assumes the project's hierarchy to this file is:
	277	# tests/utils/python/this_file
ce8470c9 MJ	278	self._project_root = (
	279	pathlib.Path(__file__).absolute().parents[3]
	280	) # type: pathlib.Path
	281	self._lttng_home = TemporaryDirectory(
ef945e4d	282	"lttng_test_env_home"
ce8470c9	283	) # type: Optional[TemporaryDirectory]
ef945e4d	284
ce8470c9	285	self._sessiond = (
ef945e4d	286	self._launch_lttng_sessiond() if with_sessiond else None
ce8470c9	287	) # type: Optional[subprocess.Popen[bytes]]
ef945e4d JG	288
ef945e4d JG	289	@property
ce8470c9 MJ	290	def lttng_home_location(self):
ce8470c9 MJ	291	# type: () -> pathlib.Path
ef945e4d JG	292	if self._lttng_home is None:
	293	raise RuntimeError("Attempt to access LTTng home after clean-up")
	294	return self._lttng_home.path
	295
	296	@property
ce8470c9 MJ	297	def lttng_client_path(self):
ce8470c9 MJ	298	# type: () -> pathlib.Path
ef945e4d JG	299	return self._project_root / "src" / "bin" / "lttng" / "lttng"
ef945e4d JG	300
ce8470c9 MJ	301	def create_temporary_directory(self, prefix=None):
ce8470c9 MJ	302	# type: (Optional[str]) -> pathlib.Path
ef945e4d JG	303	# Simply return a path that is contained within LTTNG_HOME; it will
	304	# be destroyed when the temporary home goes out of scope.
	305	assert self._lttng_home
	306	return pathlib.Path(
	307	tempfile.mkdtemp(
	308	prefix="tmp" if prefix is None else prefix,
	309	dir=str(self._lttng_home.path),
	310	)
	311	)
	312
	313	# Unpack a list of environment variables from a string
	314	# such as "HELLO=is_it ME='/you/are/looking/for'"
	315	@staticmethod
ce8470c9 MJ	316	def _unpack_env_vars(env_vars_string):
ce8470c9 MJ	317	# type: (str) -> List[Tuple[str, str]]
ef945e4d JG	318	unpacked_vars = []
	319	for var in shlex.split(env_vars_string):
	320	equal_position = var.find("=")
	321	# Must have an equal sign and not end with an equal sign
	322	if equal_position == -1 or equal_position == len(var) - 1:
	323	raise ValueError(
	324	"Invalid sessiond environment variable: `{}`".format(var)
	325	)
	326
	327	var_name = var[0:equal_position]
	328	var_value = var[equal_position + 1 :]
	329	# Unquote any paths
	330	var_value = var_value.replace("'", "")
	331	var_value = var_value.replace('"', "")
	332	unpacked_vars.append((var_name, var_value))
	333
	334	return unpacked_vars
	335
ce8470c9 MJ	336	def _launch_lttng_sessiond(self):
ce8470c9 MJ	337	# type: () -> Optional[subprocess.Popen]
ef945e4d JG	338	is_64bits_host = sys.maxsize > 2**32
	339
	340	sessiond_path = (
	341	self._project_root / "src" / "bin" / "lttng-sessiond" / "lttng-sessiond"
	342	)
	343	consumerd_path_option_name = "--consumerd{bitness}-path".format(
	344	bitness="64" if is_64bits_host else "32"
	345	)
	346	consumerd_path = (
	347	self._project_root / "src" / "bin" / "lttng-consumerd" / "lttng-consumerd"
	348	)
	349
	350	no_sessiond_var = os.environ.get("TEST_NO_SESSIOND")
	351	if no_sessiond_var and no_sessiond_var == "1":
	352	# Run test without a session daemon; the user probably
	353	# intends to run one under gdb for example.
	354	return None
	355
	356	# Setup the session daemon's environment
	357	sessiond_env_vars = os.environ.get("LTTNG_SESSIOND_ENV_VARS")
	358	sessiond_env = os.environ.copy()
	359	if sessiond_env_vars:
	360	self._log("Additional lttng-sessiond environment variables:")
	361	additional_vars = self._unpack_env_vars(sessiond_env_vars)
	362	for var_name, var_value in additional_vars:
	363	self._log(" {name}={value}".format(name=var_name, value=var_value))
	364	sessiond_env[var_name] = var_value
	365
	366	sessiond_env["LTTNG_SESSION_CONFIG_XSD_PATH"] = str(
	367	self._project_root / "src" / "common"
	368	)
	369
	370	assert self._lttng_home is not None
	371	sessiond_env["LTTNG_HOME"] = str(self._lttng_home.path)
	372
	373	wait_queue = _SignalWaitQueue()
0ac0f70e JG	374	with wait_queue.intercept_signal(signal.SIGUSR1):
	375	self._log(
	376	"Launching session daemon with LTTNG_HOME=`{home_dir}`".format(
	377	home_dir=str(self._lttng_home.path)
	378	)
	379	)
	380	process = subprocess.Popen(
	381	[
	382	str(sessiond_path),
	383	consumerd_path_option_name,
	384	str(consumerd_path),
	385	"--sig-parent",
	386	],
	387	stdout=subprocess.PIPE,
	388	stderr=subprocess.STDOUT,
	389	env=sessiond_env,
ef945e4d	390	)
ef945e4d	391
0ac0f70e JG	392	if self._logging_function:
	393	self._sessiond_output_consumer = ProcessOutputConsumer(
	394	process, "lttng-sessiond", self._logging_function
	395	) # type: Optional[ProcessOutputConsumer]
	396	self._sessiond_output_consumer.daemon = True
	397	self._sessiond_output_consumer.start()
ef945e4d	398
0ac0f70e JG	399	# Wait for SIGUSR1, indicating the sessiond is ready to proceed
0ac0f70e JG	400	wait_queue.wait_for_signal()
ef945e4d JG	401
	402	return process
	403
ce8470c9 MJ	404	def _handle_termination_signal(self, signal_number, frame):
ce8470c9 MJ	405	# type: (int, Optional[FrameType]) -> None
ef945e4d JG	406	self._log(
	407	"Killed by {signal_name} signal, cleaning-up".format(
	408	signal_name=signal.strsignal(signal_number)
	409	)
	410	)
	411	self._cleanup()
	412
ce8470c9 MJ	413	def launch_wait_trace_test_application(self, event_count):
ce8470c9 MJ	414	# type: (int) -> WaitTraceTestApplication
ef945e4d JG	415	"""
	416	Launch an application that will wait before tracing `event_count` events.
	417	"""
	418	return WaitTraceTestApplication(
	419	self._project_root
	420	/ "tests"
	421	/ "utils"
	422	/ "testapp"
	423	/ "gen-ust-nevents"
	424	/ "gen-ust-nevents",
	425	event_count,
	426	self,
	427	)
	428
873d3601 MJ	429	def launch_trace_test_constructor_application(self):
873d3601 MJ	430	# type () -> TraceTestApplication
da1e97c9 MD	431	"""
	432	Launch an application that will trace from within constructors.
	433	"""
	434	return TraceTestApplication(
	435	self._project_root
	436	/ "tests"
	437	/ "utils"
	438	/ "testapp"
	439	/ "gen-ust-events-constructor"
	440	/ "gen-ust-events-constructor",
	441	self,
	442	)
	443
ef945e4d	444	# Clean-up managed processes
ce8470c9 MJ	445	def _cleanup(self):
ce8470c9 MJ	446	# type: () -> None
ef945e4d JG	447	if self._sessiond and self._sessiond.poll() is None:
	448	# The session daemon is alive; kill it.
	449	self._log(
	450	"Killing session daemon (pid = {sessiond_pid})".format(
	451	sessiond_pid=self._sessiond.pid
	452	)
	453	)
	454
	455	self._sessiond.terminate()
	456	self._sessiond.wait()
	457	if self._sessiond_output_consumer:
	458	self._sessiond_output_consumer.join()
	459	self._sessiond_output_consumer = None
	460
	461	self._log("Session daemon killed")
	462	self._sessiond = None
	463
	464	self._lttng_home = None
	465
	466	def __del__(self):
	467	self._cleanup()
	468
	469
	470	@contextlib.contextmanager
ce8470c9 MJ	471	def test_environment(with_sessiond, log=None):
ce8470c9 MJ	472	# type: (bool, Optional[Callable[[str], None]]) -> Iterator[_Environment]
ef945e4d JG	473	env = _Environment(with_sessiond, log)
	474	try:
	475	yield env
	476	finally:
	477	env._cleanup()