testgres-pg-probackup2 0.9.0__tar.gz → 0.9.2__tar.gz

{testgres_pg_probackup2-0.9.0 → testgres_pg_probackup2-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres_pg_probackup2
-Version: 0.9.0
+Version: 0.9.2
 Summary: Plugin for testgres that manages pg_probackup2
 Home-page: https://github.com/postgrespro/testgres
 Author: Postgres Professional

{testgres_pg_probackup2-0.9.0 → testgres_pg_probackup2-0.9.2}/pg_probackup2/app.py

@@ -126,7 +126,7 @@ class ProbackupApp:
         if self.verbose:
             print(self.test_class.cmd)
 
-        cmdline = self._form_cmdline(binary_path, command)
+        cmdline = self._form_cmdline(binary_path, command, use_valgrind=gdb is False)
 
         if gdb is True:
             # general test flow for using GDBObj
@@ -168,35 +168,37 @@ class ProbackupApp:
 
         return command, strcommand
 
-    def _form_cmdline(self, binary_path, command):
+    def _form_cmdline(self, binary_path, command, use_valgrind=True):
         cmdline = [binary_path, *command]
 
-        if (self.valgrind == 'y' or self.valgrind_sup_path) and command[0] != "--version":
-            os.makedirs(self.pb_log_path, exist_ok=True)
-            valgrind_cmd = [
-                "valgrind",
-                "--gen-suppressions=all",
-                "--leak-check=full",
-                "--show-reachable=yes",
-                "--error-limit=no",
-                "--show-leak-kinds=all",
-                "--errors-for-leak-kinds=all",
-                "--error-exitcode=0",
-                f"--log-file={os.path.join(self.pb_log_path, f'valgrind-{command[0]}-%p.log')}"
-            ]
-            if self.valgrind_sup_path:
-                if os.path.isfile(self.valgrind_sup_path):
-                    valgrind_cmd += [f"--suppressions={self.valgrind_sup_path}"]
-                else:
-                    raise FileNotFoundError(f"PG_PROBACKUP_VALGRIND_SUP must be the path to a valgrind suppression file, "
-                                            f"but found: {self.valgrind_sup_path}")
+        if not use_valgrind or command[0] == "--version":
+            return cmdline
+        if self.valgrind != 'y' and not self.valgrind_sup_path:
+            return cmdline
+
+        os.makedirs(self.pb_log_path, exist_ok=True)
+        valgrind_cmd = [
+            "valgrind",
+            "--gen-suppressions=all",
+            "--leak-check=full",
+            "--show-reachable=yes",
+            "--error-limit=no",
+            "--show-leak-kinds=all",
+            "--errors-for-leak-kinds=all",
+            "--error-exitcode=0",
+            f"--log-file={os.path.join(self.pb_log_path, f'valgrind-{command[0]}-%p.log')}"
+        ]
+        if self.valgrind_sup_path:
+            if os.path.isfile(self.valgrind_sup_path):
+                valgrind_cmd += [f"--suppressions={self.valgrind_sup_path}"]
             else:
-                # Assume the tests are started from the root of pg_probackup repository
-                valgrind_cmd += [f"--suppressions=.valgrind.supp"]
-
-            cmdline = valgrind_cmd + cmdline
+                raise FileNotFoundError(f"PG_PROBACKUP_VALGRIND_SUP must be the path to a valgrind suppression file, "
+                                        f"but found: {self.valgrind_sup_path}")
+        else:
+            # Assume the tests are started from the root of pg_probackup repository
+            valgrind_cmd += [f"--suppressions=.valgrind.supp"]
 
-        return cmdline
+        return valgrind_cmd + cmdline
 
     def _execute_command(self, cmdline, env, command, gdb, expect_error, return_id, daemonize):
         try:

{testgres_pg_probackup2-0.9.0 → testgres_pg_probackup2-0.9.2}/pg_probackup2/gdb.py

@@ -134,6 +134,8 @@ class GDBobj:
         )
 
     def remove_all_breakpoints(self):
+        if self._did_quit:
+            return
         if not self.has_breakpoint:
             return
 
@@ -149,6 +151,8 @@ class GDBobj:
         )
 
     def run_until_break(self):
+        if self._did_quit:
+            return
         result = self._execute('run', False)
         for line in result:
             if line.startswith('*stopped,reason="breakpoint-hit"'):
@@ -158,6 +162,8 @@ class GDBobj:
         )
 
     def continue_execution_until_running(self):
+        if self._did_quit:
+            return
         result = self._execute('continue')
 
         for line in result:
@@ -175,9 +181,23 @@ class GDBobj:
     def signal(self, sig):
         if 'KILL' in sig:
             self.remove_all_breakpoints()
+            # Avoid GDB 15.x SIGABRT: kill inferior directly, not via `signal`.
+            try:
+                pids = subprocess.check_output(
+                    ['pgrep', '-P', str(self.gdb_pid)],
+                    text=True
+                ).strip().split()
+                for pid in pids:
+                    os.kill(int(pid), 9)
+            except (subprocess.CalledProcessError, ValueError, OSError):
+                pass
+            self.kill()
+            return
         self._execute(f'signal {sig}')
 
     def continue_execution_until_exit(self):
+        if self._did_quit:
+            return
         self.remove_all_breakpoints()
         result = self._execute('continue', False)
 
@@ -195,6 +215,8 @@ class GDBobj:
         )
 
     def continue_execution_until_error(self):
+        if self._did_quit:
+            return
         self.remove_all_breakpoints()
         result = self._execute('continue', False)
 
@@ -211,6 +233,8 @@ class GDBobj:
             'Failed to continue execution until error.\n')
 
     def continue_execution_until_break(self, ignore_count=0):
+        if self._did_quit:
+            return
         if ignore_count > 0:
             result = self._execute(
                 'continue ' + str(ignore_count),
@@ -253,6 +277,8 @@ class GDBobj:
 
     # use for breakpoint, run, continue
     def _execute(self, cmd, running=True):
+        if self._did_quit:
+            return []
         output = []
         self.proc.stdin.flush()
         self.proc.stdin.write(cmd + '\n')
@@ -320,9 +346,9 @@ def needs_gdb(func):
     check = _check_gdb_flag_or_skip_test()
     if not check:
         @functools.wraps(func)
-        def ok_wrapped(self):
+        def ok_wrapped(self, *args, **kwargs):
             self._gdb_decorated = True
-            func(self)
+            return func(self, *args, **kwargs)
 
         return ok_wrapped
     reason = check[1]
@@ -330,7 +356,7 @@ def needs_gdb(func):
         return unittest.skip(reason)(func)
     elif check[0] == "fail":
         @functools.wraps(func)
-        def fail_wrapper(self):
+        def fail_wrapper(self, *args, **kwargs):
             self.fail(reason)
 
         return fail_wrapper

{testgres_pg_probackup2-0.9.0 → testgres_pg_probackup2-0.9.2}/pg_probackup2/init_helpers.py

@@ -9,7 +9,7 @@ import subprocess
 import sys
 import traceback
 import testgres
-from testgres.operations.exceptions import InvalidOperationException
+import typing
 
 try:
     import lz4.frame  # noqa: F401
@@ -38,7 +38,46 @@ except Exception as e:
     logging.warning("Can't configure testgres: {0}".format(e))
 
 
+class InitData_ServerProps:
+    pgpro_edition: typing.Optional[str]
+    num_version: int
+
+    def __init__(
+        self,
+        pgpro_edition: typing.Optional[str],
+        num_version: int,
+    ):
+        assert pgpro_edition is None or type(pgpro_edition) is str
+        assert type(num_version) is int
+        self.pgpro_edition = pgpro_edition
+        self.num_version = num_version
+        return
+
+
+class InitData_BinaryName:
+    pg_config: str
+    postgres: str
+    initdb: str
+
+    def __init__(
+        self,
+        pg_config: str,
+        initdb: str,
+        postgres: str,
+    ):
+        assert type(pg_config) is str
+        assert type(postgres) is str
+        assert type(initdb) is str
+
+        self.pg_config = pg_config
+        self.postgres = postgres
+        self.initdb = initdb
+        return
+
+
 class Init(object):
+    _server_props: InitData_ServerProps
+
     def __init__(self):
         if '-v' in sys.argv or '--verbose' in sys.argv:
             self.verbose = True
@@ -50,21 +89,38 @@ class Init(object):
 
         pg_bin = testgres.get_bin_dir(os_ops)
         if pg_bin is None:
-            raise InvalidOperationException(
-                "Failed to determine the Postgres binary directory. Specify the path to the directory in PG_BIN or put it into the system PATH.")
-        postgres = os_ops.build_path(pg_bin, 'postgres.exe' if os_name == 'nt' else 'postgres')
+            raise testgres.InvalidOperationException(
+                "Failed to determine the Postgres binary directory. Specify the path to the directory in PG_BIN or put it into the system PATH.",
+            )
+
+        if not os_ops.path_exists(pg_bin):
+            raise testgres.InvalidOperationException(
+                "Path [{}] is not found.".format(pg_bin),
+            )
+
+        pg_config_path = os_ops.build_path(
+            pg_bin,
+            __class__._get_binary_names(os_ops).pg_config,
+        )
 
-        pgpro_edition = os_ops.exec_command(
-            [postgres, "-C", "pgpro_edition"],
-            encoding='utf-8',
-            ignore_errors=True).rstrip()
-        self.is_enterprise = pgpro_edition == 'enterprise'
-        self.is_shardman = pgpro_edition == 'shardman'
-        self.is_pgpro = pgpro_edition != ''
+        assert type(pg_config_path) is str
+
+        if os_ops.path_exists(pg_config_path):
+            self._server_props = __class__._init__get_server_props__via_pg_config(
+                os_ops,
+                pg_config_path,
+            )
+        else:
+            self._server_props = __class__._init__get_server_props__via_server(
+                os_ops,
+                pg_bin,
+            )
 
         # TODO: Always test with NLS support and remove this flag
         self.is_nls_enabled = True
 
+        postgres = os_ops.build_path(pg_bin, 'postgres.exe' if os_name == 'nt' else 'postgres')
+
         if os_name == 'posix':
             ldd = os_ops.exec_command(
                 ['ldd', postgres],
@@ -81,19 +137,11 @@ class Init(object):
                     break
         else:
             # Fall back to trying to determine lz4 support via pg_config
-            pg_config = testgres.get_pg_config(os_ops=os_ops)
-            self.is_lz4_enabled = '-llz4' in pg_config['LIBS']
-
-        server_version_out = os_ops.exec_command(
-            [postgres, "-C", "server_version"],
-            encoding='utf-8')
-        server_version = testgres.parse_pg_version(server_version_out)
-        parts = [*server_version.split('.'), '0', '0'][:3]
-        parts[0] = re.match(r'\d+', parts[0]).group()
-        # Server_version consists of two fields (x.y) so num_version always ends with 00
-        num_version = reduce(lambda v, x: v * 100 + int(x), parts, 0)
-        # For backward compatibility
-        self.pg_config_version = num_version
+            pg_config_data = testgres.utils.get_pg_config2(
+                pg_config_path=pg_config_path,
+                os_ops=os_ops,
+            )
+            self.is_lz4_enabled = '-llz4' in pg_config_data['LIBS']
 
         os.environ['LANGUAGE'] = 'en'   # set default locale language to en. All messages will use this locale
         test_env = os.environ.copy()
@@ -163,7 +211,7 @@ class Init(object):
                     self.probackup_path = probackup_path_tmp
 
         if not self.probackup_path:
-            raise Exception('pg_probackup binary is not found')
+            raise Exception('pg_probackup binary is not found, add it to PATH or point PGPROBACKUPBIN')
 
         if os_name == 'posix':
             self.EXTERNAL_DIRECTORY_DELIMITER = ':'
@@ -210,7 +258,7 @@ class Init(object):
             self.old_probackup_version = match.group(0) if match else None
 
         self.remote = test_env.get('PGPROBACKUP_SSH_REMOTE', None) == 'ON'
-        self.ptrack = test_env.get('PG_PROBACKUP_PTRACK', None) == 'ON' and num_version >= 110000
+        self.ptrack = test_env.get('PG_PROBACKUP_PTRACK', None) == 'ON' and self._server_props.num_version >= 110000
         self.wal_tree_enabled = test_env.get('PG_PROBACKUP_WAL_TREE_ENABLED', None) == 'ON'
 
         self.bckp_source = test_env.get('PG_PROBACKUP_SOURCE', 'pro').lower()
@@ -262,6 +310,151 @@ class Init(object):
     def test_env(self):
         return self._test_env.copy()
 
+    @property
+    def is_enterprise(self) -> bool:
+        assert type(self._server_props) is InitData_ServerProps
+        return self._server_props.pgpro_edition == 'enterprise'
+
+    @property
+    def is_shardman(self) -> bool:
+        assert type(self._server_props) is InitData_ServerProps
+        return self._server_props.pgpro_edition == 'shardman'
+
+    @property
+    def is_pgpro(self) -> bool:
+        assert type(self._server_props) is InitData_ServerProps
+        return self._server_props.pgpro_edition is not None
+
+    @property
+    def pg_config_version(self) -> int:
+        assert type(self._server_props) is InitData_ServerProps
+        return self._server_props.num_version
+
+    @staticmethod
+    def _init__get_server_props__via_pg_config(
+        os_ops: testgres.OsOperations,
+        pg_config_path: str,
+    ) -> InitData_ServerProps:
+        assert isinstance(os_ops, testgres.OsOperations)
+        assert type(pg_config_path) is str
+
+        pg_config = testgres.utils.get_pg_config2(
+            pg_config_path=pg_config_path,
+            os_ops=os_ops,
+        )
+        assert type(pg_config) is dict
+
+        pgpro_edition = pg_config.get('PGPRO_EDITION')
+        assert pgpro_edition is None or type(pgpro_edition) is str
+
+        version_str = pg_config.get('VERSION', '')
+        assert type(version_str) is str
+
+        if not version_str:
+            raise RuntimeError("Field 'VERSION' not found in pg_config output")
+
+        version_num = testgres.parse_pg_version(version_str)
+        parts = [*version_num.split('.'), '0', '0'][:3]
+        parts[0] = re.match(r'\d+', parts[0]).group()
+
+        num_version = reduce(lambda v, x: v * 100 + int(x), parts, 0)
+        assert type(num_version) is int
+
+        return InitData_ServerProps(
+            pgpro_edition=pgpro_edition,
+            num_version=num_version,
+        )
+
+    @staticmethod
+    def _init__get_server_props__via_server(
+        os_ops: testgres.OsOperations,
+        pg_bin_dir: str,
+    ) -> InitData_ServerProps:
+        assert isinstance(os_ops, testgres.OsOperations)
+        assert type(pg_bin_dir) is str
+
+        tmpdir = os_ops.mkdtemp()
+        assert type(tmpdir) is str
+        assert os_ops.path_exists(tmpdir)
+        assert os_ops.is_abs_path(tmpdir)
+
+        try:
+            initdb = os_ops.build_path(
+                pg_bin_dir,
+                __class__._get_binary_names(os_ops).initdb,
+            )
+
+            os_ops.exec_command(
+                [initdb, "-D", tmpdir],
+                encoding='utf-8',
+            )
+
+            postgres = os_ops.build_path(
+                pg_bin_dir,
+                __class__._get_binary_names(os_ops).postgres,
+            )
+
+            pgpro_edition_out: typing.Optional[str] = None
+            try:
+                exec_r = os_ops.exec_command(
+                    [postgres, "-C", "pgpro_edition", "-D", tmpdir],
+                    encoding='utf-8',
+                )
+                assert type(exec_r) is str
+                pgpro_edition_out = exec_r.strip()
+            except testgres.ExecUtilException as e:
+                assert e.exit_code != 0
+
+                logging.debug("Exception ({}): {}".format(
+                    type(e).__name__,
+                    e,
+                ))
+
+            assert pgpro_edition_out is None or type(pgpro_edition_out) is str
+            pgpro_edition = pgpro_edition_out
+
+            server_version_out = os_ops.exec_command(
+                [postgres, "-C", "server_version", "-D", tmpdir],
+                encoding='utf-8'
+            )
+            assert type(server_version_out) is str
+            server_version = testgres.parse_pg_version(server_version_out)
+            parts = [*server_version.split('.'), '0', '0'][:3]
+            parts[0] = re.match(r'\d+', parts[0]).group()
+            # Server_version consists of two fields (x.y) so num_version always ends with 00
+            pg_config_version = reduce(lambda v, x: v * 100 + int(x), parts, 0)
+        finally:
+            os_ops.rmdirs(tmpdir)
+
+        return InitData_ServerProps(
+            pgpro_edition=pgpro_edition,
+            num_version=pg_config_version,
+        )
+
+    sm_binary_names__win32 = InitData_BinaryName(
+        pg_config="pg_config.exe",
+        initdb="initdb.exe",
+        postgres="postgres.exe",
+    )
+
+    sm_binary_names__linux = InitData_BinaryName(
+        pg_config="pg_config",
+        initdb="initdb",
+        postgres="postgres",
+    )
+
+    @staticmethod
+    def _get_binary_names(
+        os_ops: testgres.OsOperations,
+    ) -> InitData_BinaryName:
+        assert isinstance(os_ops, testgres.OsOperations)
+
+        platform_name = os_ops.get_platform()
+        if platform_name == "win32":
+            return __class__.sm_binary_names__win32
+
+        return __class__.sm_binary_names__linux
+
 
 try:
     init_params = Init()

{testgres_pg_probackup2-0.9.0 → testgres_pg_probackup2-0.9.2}/setup.py

@@ -4,7 +4,7 @@ except ImportError:
     from distutils.core import setup
 
 setup(
-    version='0.9.0',
+    version='0.9.2',
     name='testgres_pg_probackup2',
     packages=['pg_probackup2', 'pg_probackup2.storage'],
     description='Plugin for testgres that manages pg_probackup2',

{testgres_pg_probackup2-0.9.0 → testgres_pg_probackup2-0.9.2}/testgres_pg_probackup2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres_pg_probackup2
-Version: 0.9.0
+Version: 0.9.2
 Summary: Plugin for testgres that manages pg_probackup2
 Home-page: https://github.com/postgrespro/testgres
 Author: Postgres Professional

testgres_pg_probackup2-0.9.0/pg_probackup2/__init__.py

@@ -1 +0,0 @@
-

testgres_pg_probackup2-0.9.0/pg_probackup2/storage/__init__.py

@@ -1 +0,0 @@
-