testgres 1.14.4__tar.gz → 1.14.5__tar.gz

{testgres-1.14.4/testgres.egg-info → testgres-1.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.14.4
+Version: 1.14.5
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

{testgres-1.14.4 → testgres-1.14.5}/src/__init__.py

@@ -43,6 +43,7 @@ from .utils import \
     release_port, \
     bound_ports, \
     get_bin_path, \
+    get_bin_dir, \
     get_pg_config, \
     get_pg_version, \
     parse_pg_version
@@ -57,7 +58,7 @@ from testgres.operations.os_ops import OsOperations, ConnectionParams
 from testgres.operations.local_ops import LocalOperations
 from testgres.operations.remote_ops import RemoteOperations
 
-__version__ = "1.14.4"
+__version__ = "1.14.5"
 
 __all__ = [
     "get_new_node",
@@ -72,7 +73,7 @@ __all__ = [
     "NodeApp",
     "PostgresNode",
     "PortManager",
-    "reserve_port", "release_port", "bound_ports", "get_bin_path", "get_pg_config", "get_pg_version", "parse_pg_version",
+    "reserve_port", "release_port", "bound_ports", "get_bin_path", "get_bin_dir", "get_pg_config", "get_pg_version", "parse_pg_version",
     "First", "Any",
     "OsOperations", "LocalOperations", "RemoteOperations", "ConnectionParams"
 ]

{testgres-1.14.4 → testgres-1.14.5}/src/connection.py

@@ -14,7 +14,7 @@ from .enums import IsolationLevel
 
 from .defaults import \
     default_dbname, \
-    default_username
+    default_username2
 
 from .exceptions import QueryException
 
@@ -38,7 +38,7 @@ class NodeConnection(object):
 
         # Set default arguments
         dbname = dbname or default_dbname()
-        username = username or default_username()
+        username = username or default_username2(node.os_ops)
 
         self._node = node
 

{testgres-1.14.4 → testgres-1.14.5}/src/defaults.py

@@ -1,6 +1,9 @@
 import datetime
 import struct
 import uuid
+import typing
+
+from testgres.operations.os_ops import OsOperations
 
 from .config import testgres_config as tconf
 
@@ -13,11 +16,30 @@ def default_dbname():
     return 'postgres'
 
 
-def default_username():
+def default_username(os_ops: typing.Optional[OsOperations] = None) -> str:
     """
     Return default username (current user).
     """
-    return tconf.os_ops.get_user()
+    assert os_ops is None or isinstance(os_ops, OsOperations)
+
+    if os_ops is None:
+        os_ops = tconf.os_ops
+
+    assert isinstance(os_ops, OsOperations)
+    result = default_username2(os_ops)
+    assert type(result) is str
+    return result
+
+
+def default_username2(os_ops: OsOperations) -> str:
+    """
+    Return default username (current user).
+    """
+    assert isinstance(os_ops, OsOperations)
+
+    result = os_ops.get_user()
+    assert type(result) is str
+    return result
 
 
 def generate_app_name():

testgres-1.14.5/src/impl/file_line_reader.py

@@ -0,0 +1,80 @@
+# coding: utf-8
+
+import typing
+
+from testgres.operations.os_ops import OsOperations
+
+
+class FileLineReader:
+    _os_ops: OsOperations
+    _file_name: str
+    _file_encoding: str
+    _file_pos: int
+    _buffer_pos: int
+    _buffer: bytes
+
+    # --------------------------------------------------------------------
+    def __init__(
+        self,
+        os_ops: OsOperations,
+        file_name: str,
+        file_encoding: str = "utf-8",
+    ):
+        assert isinstance(os_ops, OsOperations)
+        assert type(file_encoding) is str
+        self._os_ops = os_ops
+        self._file_name = file_name
+        self._file_encoding = file_encoding
+        self._file_pos = 0
+        self._buffer_pos = 0
+        self._buffer = b''
+        return
+
+    # interface ----------------------------------------------------------
+    def read_line(self) -> typing.Optional[str]:
+        assert isinstance(self._os_ops, OsOperations)
+        assert type(self._buffer_pos) is int
+        assert type(self._buffer) is bytes
+        assert self._buffer_pos >= 0
+        assert self._buffer_pos <= len(self._buffer)
+
+        scan_pos = self._buffer_pos
+
+        while True:
+            sz1 = len(self._buffer)
+
+            if scan_pos == sz1:
+                block = self._os_ops.read_binary(
+                    self._file_name,
+                    self._file_pos,
+                )
+                assert type(block) is bytes
+                self._buffer += block
+                self._file_pos += len(block)
+
+            x = self._buffer.find(b'\n', scan_pos)
+
+            sz2 = len(self._buffer)
+
+            if x == -1:
+                if scan_pos == sz2:
+                    return None
+
+                if self._buffer_pos == 0:
+                    scan_pos = sz2
+                else:
+                    assert self._buffer_pos > 0
+                    self._buffer = self._buffer[self._buffer_pos:]
+                    scan_pos = sz2 - self._buffer_pos
+                    self._buffer_pos = 0
+                continue
+
+            assert x >= 0
+            assert x < sz2
+
+            b = self._buffer[self._buffer_pos:(x+1)]
+
+            s = b.decode(self._file_encoding)
+
+            self._buffer_pos = x + 1
+            return s

testgres-1.14.5/src/logger.py

@@ -0,0 +1,116 @@
+# coding: utf-8
+
+from .config import testgres_config as tconf
+from .exceptions import ExecUtilException
+from .impl.file_line_reader import FileLineReader
+
+from testgres.operations.os_ops import OsOperations
+
+import logging
+import threading
+import time
+import typing
+
+
+class TestgresLogger(threading.Thread):
+    _C_SLEEP_MIN = 0.01
+    _C_SLEEP_MAX = 60
+
+    """
+    Helper class to implement reading from log files.
+    """
+    def __init__(
+        self,
+        node_name: str,
+        log_file_name: str,
+        log_file_encoding: str = "utf-8",
+        os_ops: typing.Optional[OsOperations] = None,
+    ):
+        assert type(node_name) is str
+        assert type(log_file_name) is str
+        assert type(log_file_encoding) is str
+        assert os_ops is None or isinstance(os_ops, OsOperations)
+
+        threading.Thread.__init__(self)
+
+        if os_ops is None:
+            os_ops = tconf.os_ops
+
+        assert os_ops is None or isinstance(os_ops, OsOperations)
+
+        self._os_ops = os_ops
+        self._node_name = node_name
+        self._log_file_name = log_file_name
+        self._log_file_encoding = log_file_encoding
+        self._stop_event = threading.Event()
+        self._logger = logging.getLogger(node_name)
+        self._logger.setLevel(logging.INFO)
+        return
+
+    def run(self):
+        # open log file for reading
+        file_line_reader = FileLineReader(
+            self._os_ops,
+            self._log_file_name,
+            self._log_file_encoding,
+        )
+
+        sleep_time = __class__._C_SLEEP_MIN
+
+        try:
+            # work until we're asked to stop
+            while not self._stop_event.is_set():
+                line = None
+
+                while True:
+                    try:
+                        line = file_line_reader.read_line()  # raise
+                    except Exception as e:
+                        if __class__._is_file_not_found_exception(e):
+                            if not self._os_ops.path_exists(self._log_file_name):
+                                break
+                        raise
+                    break
+
+                if line is None:
+                    time.sleep(sleep_time)
+                    sleep_time = min(__class__._C_SLEEP_MAX, 2 * sleep_time)
+                    continue
+
+                assert type(line) is str
+
+                sleep_time = __class__._C_SLEEP_MIN
+
+                # do we have new lines?
+                line = line.strip()
+
+                extra = {'node': self._node_name}
+                self._logger.info(line, extra=extra)
+                continue
+        except Exception as e:
+            self._logger.error(e)
+            raise
+        finally:
+            # don't forget to clear event
+            # [2026-07-10] legacy cargo cult, thread is single-use only.
+            # self._stop_event.clear()
+            pass
+        return
+
+    def stop(self, wait=True):
+        self._stop_event.set()
+
+        if wait:
+            self.join()
+        return
+
+    @staticmethod
+    def _is_file_not_found_exception(e: Exception) -> bool:
+        if isinstance(e, FileNotFoundError):
+            return True
+
+        if isinstance(e, ExecUtilException):
+            if e.exit_code == 2:
+                return True
+
+        return False

{testgres-1.14.4 → testgres-1.14.5}/src/node.py

@@ -729,7 +729,11 @@ class PostgresNode(object):
         if testgres_config.use_python_logging:
             # spawn new logger if it doesn't exist or is stopped
             if not self._logger or not self._logger.is_alive():
-                self._logger = TestgresLogger(self.name, self.pg_log_file)
+                self._logger = TestgresLogger(
+                    self.name,
+                    self.pg_log_file,
+                    os_ops=self._os_ops,
+                )
                 self._logger.start()
 
     def _maybe_stop_logger(self):
@@ -807,7 +811,7 @@ class PostgresNode(object):
         Args:
             fsync: should this node use fsync to keep data safe?
             unix_sockets: should we enable UNIX sockets?
-            allow_streaming: should this node add a hba entry for replication?
+            allow_streaming: (ignored) should this node add a hba entry for replication?
             allow_logical: can this node be used as a logical replication publisher?
             log_statement: one of ('all', 'off', 'mod', 'ddl').
 
@@ -818,44 +822,10 @@ class PostgresNode(object):
         assert self._os_ops is not None
         assert isinstance(self._os_ops, OsOperations)
 
-        postgres_conf = self._os_ops.build_path(self.data_dir, PG_CONF_FILE)
-        hba_conf = self._os_ops.build_path(self.data_dir, HBA_CONF_FILE)
-
-        # filter lines in hba file
-        # get rid of comments and blank lines
-        hba_conf_file = self._os_ops.readlines(hba_conf)
-        lines = [
-            s for s in hba_conf_file
-            if len(s.strip()) > 0 and not s.startswith('#')
-        ]
-
-        # write filtered lines
-        self._os_ops.write(hba_conf, lines, truncate=True)
+        # hba file is updated
+        self._default_conf__hba()
 
-        # replication-related settings
-        if allow_streaming:
-            # get auth method for host or local users
-            def get_auth_method(t):
-                return next((s.split()[-1]
-                             for s in lines if s.startswith(t)), 'trust')
-
-            # get auth methods
-            auth_local = get_auth_method('local')
-            auth_host = get_auth_method('host')
-            subnet_base = ".".join(self._os_ops.host.split('.')[:-1] + ['0'])
-
-            new_lines = [
-                u"local\treplication\tall\t\t\t{}\n".format(auth_local),
-                u"host\treplication\tall\t127.0.0.1/32\t{}\n".format(auth_host),
-                u"host\treplication\tall\t::1/128\t\t{}\n".format(auth_host),
-                u"host\treplication\tall\t{}/24\t\t{}\n".format(subnet_base, auth_host),
-                u"host\tall\tall\t{}/24\t\t{}\n".format(subnet_base, auth_host),
-                u"host\tall\tall\tall\t{}\n".format(auth_host),
-                u"host\treplication\tall\tall\t{}\n".format(auth_host)
-            ]  # yapf: disable
-
-            # write missing lines
-            self._os_ops.write(hba_conf, new_lines)
+        postgres_conf = self._os_ops.build_path(self.data_dir, PG_CONF_FILE)
 
         # overwrite config file
         self._os_ops.write(postgres_conf, '', truncate=True)
@@ -901,6 +871,88 @@ class PostgresNode(object):
 
         return self
 
+    def _default_conf__hba(self) -> None:
+        hba_conf = self._os_ops.build_path(self.data_dir, HBA_CONF_FILE)
+
+        # filter lines in hba file
+        # get rid of comments and blank lines
+        hba_conf_file = self._os_ops.readlines(hba_conf, binary=False)
+
+        assert type(hba_conf_file) is list
+
+        hba_conf_file_finished_with_eol = True
+        if len(hba_conf_file) > 0:
+            last_line = hba_conf_file[-1]
+            assert type(last_line) is str
+            hba_conf_file_finished_with_eol = last_line.endswith("\n")
+
+        # Normalize function: turns a string into a list of pure words
+        def normalize_line(line_str):
+            return line_str.strip().split()
+
+        # We collect a list of rules that already exist in the file (in the form of word lists)
+        existing_normalized = []
+        for s in hba_conf_file:
+            s_clean = s.strip()
+            if s_clean and not s_clean.startswith("#"):
+                existing_normalized.append(normalize_line(s_clean))
+            continue
+
+        # get auth method for host or local users
+        def get_auth_method(t):
+            for x in existing_normalized:
+                assert type(x) is list
+                if len(x) > 0 and x[0] == t:
+                    return x[-1]
+                continue
+            return 'trust'
+
+        # get auth methods
+        auth_local = get_auth_method('local')
+        auth_host = get_auth_method('host')
+
+        # Basic rules that we want to see in the file
+        raw_rules = [
+            ("local", "replication", "all", "", auth_local),
+            ("host", "replication", "all", "0.0.0.0/0", auth_host),
+            ("host", "replication", "all", "::/0", auth_host),
+            ("local", "all", "all", "", auth_local),
+            ("host", "all", "all", "0.0.0.0/0", auth_host),
+            ("host", "all", "all", "::/0", auth_host),
+        ]
+
+        add_rules = []
+
+        for type_hba, db, user, addr, method in raw_rules:
+            # We check if such a rule already exists in the file (by meaning, not by tabs!)
+            target_words = [type_hba, db, user, method]
+            if addr:
+                target_words.insert(3, addr)
+
+            if target_words in existing_normalized:
+                continue  # Такое правило уже есть, пропускаем!
+
+            # Beautiful, smooth enterprise formatting with spaces!
+            # Text will be left-aligned and aligned strictly within columns.
+            formatted_rule = "{:<8} {:<16} {:<16} {:<24} {}\n".format(
+                type_hba, db, user, addr if addr else "", method
+            )
+            add_rules.append(formatted_rule)
+            continue
+
+        if len(add_rules) > 0:
+            add_lines = []
+            if not hba_conf_file_finished_with_eol:
+                add_lines.append("\n")
+
+            add_lines.append("\n")
+            add_lines.append("# Testgres default configuration\n")
+            add_lines += add_rules
+
+            # We add only real, beautifully formatted new items
+            self._os_ops.write(hba_conf, add_lines, truncate=False)
+        return
+
     @method_decorator(positional_args_hack(['filename', 'line']))
     def append_conf(self, line='', filename=PG_CONF_FILE, **kwargs):
         """
@@ -2318,9 +2370,11 @@ class PostgresNode(object):
 class PostgresNodeLogReader:
     class LogInfo:
         position: int
+        tail: bytes
 
         def __init__(self, position: int):
             self.position = position
+            self.tail = b''
 
     # --------------------------------------------------------------------
     class LogDataBlock:
@@ -2396,38 +2450,63 @@ class PostgresNodeLogReader:
             assert type(file_name) is str
             assert type(cur_log_info) is __class__.LogInfo
 
-            read_pos = 0
-
-            if file_name in self._logs.keys():
+            if file_name not in self._logs.keys():
+                read_pos = 0
+                file_content_b = b''
+            else:
                 prev_log_info = self._logs[file_name]
                 assert type(prev_log_info) is __class__.LogInfo
                 read_pos = prev_log_info.position  # the previous size
+                file_content_b = prev_log_info.tail
 
-            file_content_b = self._node.os_ops.read_binary(file_name, read_pos)
+            prev_data_sz = len(file_content_b)
+            assert prev_data_sz <= read_pos
+
+            file_content_b += self._node.os_ops.read_binary(file_name, read_pos)
             assert type(file_content_b) is bytes
 
+            assert prev_data_sz <= len(file_content_b)
+
             #
-            # A POTENTIAL PROBLEM: file_content_b may contain an incompleted UTF-8 symbol.
+            # We will process completed lines only
             #
-            file_content_s = file_content_b.decode()
-            assert type(file_content_s) is str
+            completed_data_size = file_content_b.rfind(b"\n") + 1
 
-            next_read_pos = read_pos + len(file_content_b)
+            assert completed_data_size >= 0
+            assert completed_data_size <= len(file_content_b)
 
-            # It is a research/paranoja check.
-            # When we will process partial UTF-8 symbol, it must be adjusted.
-            assert cur_log_info.position <= next_read_pos
+            completed_data = file_content_b[:completed_data_size]
+            assert type(completed_data) is bytes
+            assert len(completed_data) == completed_data_size
 
-            cur_log_info.position = next_read_pos
+            new_tail = file_content_b[completed_data_size:]
+            assert type(new_tail) is bytes
+            assert len(new_tail) == len(file_content_b) - completed_data_size
+
+            completed_data_s = completed_data.decode()
+            assert type(completed_data_s) is str
+
+            next_read_pos = read_pos - prev_data_sz + len(file_content_b)
+
+            assert read_pos <= next_read_pos
+
+            # It is a FINAL paranoja check.
+            # [2026-07-10] Verified
+            assert cur_log_info.position <= next_read_pos
 
             block = __class__.LogDataBlock(
                 file_name,
                 read_pos,
-                file_content_s
+                completed_data_s,
             )
 
             result.append(block)
 
+            # Save information to next iteration
+            cur_log_info.position = next_read_pos
+            cur_log_info.tail = new_tail
+            continue
+
         # A new check point
         self._logs = cur_logs
 

{testgres-1.14.4 → testgres-1.14.5}/src/pubsub.py

@@ -45,7 +45,7 @@ PostgresNode(name='...', port=..., base_dir='...')
 from six import raise_from
 
 from .consts import LOGICAL_REPL_MAX_CATCHUP_ATTEMPTS
-from .defaults import default_dbname, default_username
+from .defaults import default_dbname, default_username2
 from .exceptions import CatchUpException
 from .utils import options_string
 
@@ -63,23 +63,46 @@ class Publication(object):
             dbname: database name used to connect and perform subscription.
             username: username used to connect to the database.
         """
+        assert type(name) is str
+        assert node is not None
+        assert node.os_ops is not None
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
         self.name = name
         self.node = node
         self.dbname = dbname or default_dbname()
-        self.username = username or default_username()
+        self.username = username or default_username2(node.os_ops)
 
         # create publication in database
         t = "table " + ", ".join(tables) if tables else "all tables"
         query = "create publication {} for {}"
-        node.execute(query.format(name, t), dbname=dbname, username=username)
+        self.node.execute(
+            query.format(name, t),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def drop(self, dbname=None, username=None):
         """
         Drop publication
         """
-        self.node.execute("drop publication {}".format(self.name),
-                          dbname=dbname,
-                          username=username)
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   dbname and username are ignored.
+        #   We will use settings of our object.
+        #
+        assert dbname is None or dbname == self.dbname
+        assert username is None or username == self.username
+
+        self.node.execute(
+            "drop publication {}".format(self.name),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def add_tables(self, tables, dbname=None, username=None):
         """
@@ -89,13 +112,26 @@ class Publication(object):
         Args:
             tables: a list of tables to be added to the publication.
         """
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   dbname and username are ignored.
+        #   We will use settings of our object.
+        #
+        assert dbname is None or dbname == self.dbname
+        assert username is None or username == self.username
+
         if not tables:
             raise ValueError("Tables list is empty")
 
         query = "alter publication {} add table {}"
-        self.node.execute(query.format(self.name, ", ".join(tables)),
-                          dbname=dbname or self.dbname,
-                          username=username or self.username)
+        self.node.execute(
+            query.format(self.name, ", ".join(tables)),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
 
 class Subscription(object):
@@ -121,9 +157,17 @@ class Subscription(object):
                  <https://www.postgresql.org/docs/current/static/sql-createsubscription.html>`_
                  for details).
         """
+        assert type(name) is str
+        assert node is not None
+        assert node.os_ops is not None
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
         self.name = name
         self.node = node
         self.pub = publication
+        self.dbname = dbname or default_dbname()
+        self.username = username or default_username2(node.os_ops)
 
         # connection info
         conninfo = {
@@ -142,38 +186,99 @@ class Subscription(object):
             query += " with ({})".format(options_string(**params))
 
         # Note: cannot run 'create subscription' query in transaction mode
-        node.execute(query, dbname=dbname, username=username)
+        self.node.execute(
+            query,
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def disable(self, dbname=None, username=None):
         """
         Disables the running subscription.
         """
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   dbname and username are ignored.
+        #   We will use settings of our object.
+        #
+        assert dbname is None or dbname == self.dbname
+        assert username is None or username == self.username
+
         query = "alter subscription {} disable"
-        self.node.execute(query.format(self.name), dbname=None, username=None)
+        self.node.execute(
+            query.format(self.name),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def enable(self, dbname=None, username=None):
         """
         Enables the previously disabled subscription.
         """
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   dbname and username were and are ignored.
+        #   We will use settings of our object.
+        #
+        assert dbname is None or dbname == self.dbname
+        assert username is None or username == self.username
+
         query = "alter subscription {} enable"
-        self.node.execute(query.format(self.name), dbname=None, username=None)
+
+        self.node.execute(
+            query.format(self.name),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def refresh(self, copy_data=True, dbname=None, username=None):
         """
         Disables the running subscription.
         """
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   dbname and username are ignored.
+        #   We will use settings of our object.
+        #
+        assert dbname is None or dbname == self.dbname
+        assert username is None or username == self.username
+
         query = "alter subscription {} refresh publication with (copy_data={})"
-        self.node.execute(query.format(self.name, copy_data),
-                          dbname=dbname,
-                          username=username)
+        self.node.execute(
+            query.format(self.name, copy_data),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def drop(self, dbname=None, username=None):
         """
         Drops subscription
         """
-        self.node.execute("drop subscription {}".format(self.name),
-                          dbname=dbname,
-                          username=username)
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   dbname and username are ignored.
+        #   We will use settings of our object.
+        #
+        assert dbname is None or dbname == self.dbname
+        assert username is None or username == self.username
+
+        self.node.execute(
+            "drop subscription {}".format(self.name),
+            dbname=self.dbname,
+            username=self.username,
+        )
 
     def catchup(self, username=None):
         """
@@ -182,14 +287,32 @@ class Subscription(object):
         Args:
             username: remote node's user name.
         """
+        assert username is None or type(username) is str
+
+        #
+        # [2026-07-10] [BUG FIX]
+        #   username is ignored.
+        #   We will use settings of objects.
+        #
+        assert username is None or username == self.username
+
         try:
-            pub_lsn = self.pub.node.execute(query="select pg_current_wal_lsn()",
-                                            dbname=None,
-                                            username=None)[0][0]  # yapf: disable
+            #
+            # [2026-07-10]
+            #   About dbname=None and username=None
+            #   We will try to use self.pub.xxx the next time. OK?
+            #
+            pub_lsn = self.pub.node.execute(
+                query="select pg_current_wal_lsn()",
+                dbname=None,
+                username=None,
+            )[0][0]  # yapf: disable
             # create dummy xact, as LR replicates only on commit.
-            self.pub.node.execute(query="select txid_current()",
-                                  dbname=None,
-                                  username=None)
+            self.pub.node.execute(
+                query="select txid_current()",
+                dbname=None,
+                username=None,
+            )
             query = """
             select '{}'::pg_lsn - replay_lsn <= 0
             from pg_catalog.pg_stat_replication where application_name = '{}'
@@ -199,8 +322,9 @@ class Subscription(object):
             self.pub.node.poll_query_until(
                 query=query,
                 dbname=self.pub.dbname,
-                username=username or self.pub.username,
-                max_attempts=LOGICAL_REPL_MAX_CATCHUP_ATTEMPTS)
+                username=self.pub.username,
+                max_attempts=LOGICAL_REPL_MAX_CATCHUP_ATTEMPTS,
+            )
 
             # Now, wait until there are no tablesync workers: probably
             # replay_lsn above was sent with changes of new tables just skipped;
@@ -210,8 +334,9 @@ class Subscription(object):
             """
             self.node.poll_query_until(
                 query=query,
-                dbname=self.pub.dbname,
-                username=username or self.pub.username,
-                max_attempts=LOGICAL_REPL_MAX_CATCHUP_ATTEMPTS)
+                dbname=self.dbname,
+                username=self.username,
+                max_attempts=LOGICAL_REPL_MAX_CATCHUP_ATTEMPTS,
+            )
         except Exception as e:
             raise_from(CatchUpException("Failed to catch up"), e)

{testgres-1.14.4 → testgres-1.14.5}/src/utils.py

@@ -14,7 +14,7 @@ import typing
 
 from six import iteritems
 
-from .exceptions import ExecUtilException
+from .exceptions import ExecUtilException, InvalidOperationException
 from .config import testgres_config as tconf
 from .raise_error import RaiseError
 from .enums import NodeStatus
@@ -156,7 +156,7 @@ def get_bin_path2(os_ops: OsOperations, filename):
         pg_config = os.environ.get("PG_CONFIG")
 
     if pg_config:
-        bindir = get_pg_config(pg_config, os_ops)["BINDIR"]
+        bindir = get_pg_config2(os_ops, pg_config)["BINDIR"]
         return os_ops.build_path(bindir, filename)
 
     # try PG_BIN
@@ -166,7 +166,7 @@ def get_bin_path2(os_ops: OsOperations, filename):
 
     pg_config_path = os_ops.find_executable('pg_config')
     if pg_config_path:
-        bindir = get_pg_config(pg_config_path)["BINDIR"]
+        bindir = get_pg_config2(os_ops, pg_config_path)["BINDIR"]
         return os_ops.build_path(bindir, filename)
 
     return filename
@@ -183,8 +183,7 @@ def get_bin_dir(os_ops: OsOperations) -> str:
         pg_config = os.environ.get("PG_CONFIG")
 
     if pg_config:
-        bindir = get_pg_config(pg_config, os_ops)["BINDIR"]
-        return bindir
+        return get_pg_config2(os_ops, pg_config)["BINDIR"]
 
     # try PG_BIN
     pg_bin = os_ops.environ("PG_BIN")
@@ -193,8 +192,11 @@ def get_bin_dir(os_ops: OsOperations) -> str:
 
     pg_config_path = os_ops.find_executable('pg_config')
     if pg_config_path:
-        bindir = get_pg_config(pg_config_path)["BINDIR"]
-        return bindir
+        return get_pg_config2(os_ops, pg_config_path)["BINDIR"]
+
+    postgres = os_ops.find_executable('postgres')
+    if postgres:
+        return os_ops.get_dirname(postgres)
 
     raise RuntimeError("BinDir is not detected.")
 
@@ -261,7 +263,12 @@ def get_pg_config2(os_ops: OsOperations, pg_config_path):
         return cache_pg_config_data(cmd)
 
     # try plain name
-    return cache_pg_config_data("pg_config")
+    try:
+        pg_config_data = cache_pg_config_data("pg_config")
+    except Exception:
+        raise InvalidOperationException(
+            "Failed to determine how to start pg_config. Either specify the path to pg_config in PG_CONFIG or specify the path to the Postgres directory containing pg_config in PG_BIN, or put pg_config into the system PATH.")
+    return pg_config_data
 
 
 def get_pg_version2(os_ops: OsOperations, bin_dir=None):

{testgres-1.14.4 → testgres-1.14.5/testgres.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.14.4
+Version: 1.14.5
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

{testgres-1.14.4 → testgres-1.14.5}/testgres.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ src/pubsub.py
 src/raise_error.py
 src/standby.py
 src/utils.py
+src/impl/file_line_reader.py
 src/impl/internal_utils.py
 src/impl/port_manager__generic.py
 src/impl/port_manager__this_host.py

{testgres-1.14.4 → testgres-1.14.5}/tests/test_testgres_common.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from .helpers.global_data import OsOpsDescrs
+from .helpers.global_data import OsOpsDescr
 from .helpers.global_data import PostgresNodeService
 from .helpers.global_data import PostgresNodeServices
 from .helpers.global_data import OsOperations
@@ -16,6 +18,9 @@ from src.utils import get_pg_version2
 from src.utils import file_tail
 from src.utils import get_bin_path2
 from src.utils import execute_utility2
+from src.defaults import default_username
+from src.defaults import default_username2
+from src.config import testgres_config as tconf
 from src import ProcessType
 from src import NodeStatus
 from src import IsolationLevel
@@ -71,6 +76,25 @@ def removing(os_ops: OsOperations, f):
 
 
 class TestTestgresCommon:
+    sm_os_ops_descrs: typing.List[OsOpsDescr] = [
+        OsOpsDescrs.sm_local_os_ops_descr,
+        OsOpsDescrs.sm_remote_os_ops_descr
+    ]
+
+    @pytest.fixture(
+        params=[
+            pytest.param(
+                descr,
+                id=descr.sign,
+            )
+            for descr in sm_os_ops_descrs
+        ],
+    )
+    def os_ops_descr(self, request: pytest.FixtureRequest) -> OsOpsDescr:
+        assert isinstance(request, pytest.FixtureRequest)
+        assert isinstance(request.param, OsOpsDescr)
+        return request.param
+
     sm_node_svcs: typing.List[PostgresNodeService] = [
         PostgresNodeServices.sm_local,
         PostgresNodeServices.sm_local2,
@@ -96,7 +120,7 @@ class TestTestgresCommon:
         # Author: Mark G.
         assert v.major == 1
         assert v.minor == 14
-        assert v.micro == 4
+        assert v.micro == 5
 
         assert str(v) == testgres_version
         return
@@ -133,6 +157,37 @@ class TestTestgresCommon:
             assert (isinstance(node.version, PgVer))
             assert (node.version == PgVer(version))
 
+    def test_default_username(
+        self,
+        os_ops_descr: OsOpsDescr,
+    ):
+        assert type(os_ops_descr) is OsOpsDescr
+        assert isinstance(os_ops_descr.os_ops, OsOperations)
+
+        os_ops = os_ops_descr.os_ops
+        assert isinstance(os_ops, OsOperations)
+
+        assert default_username(os_ops) == os_ops.get_user()
+        assert default_username(os_ops) == os_ops.username
+
+        assert default_username() == tconf.os_ops.username
+        assert default_username() == tconf.os_ops.get_user()
+        return
+
+    def test_default_username2(
+        self,
+        os_ops_descr: OsOpsDescr,
+    ):
+        assert type(os_ops_descr) is OsOpsDescr
+        assert isinstance(os_ops_descr.os_ops, OsOperations)
+
+        os_ops = os_ops_descr.os_ops
+        assert isinstance(os_ops, OsOperations)
+
+        assert default_username2(os_ops) == os_ops.get_user()
+        assert default_username2(os_ops) == os_ops.username
+        return
+
     def test_node_constructor__default(self):
         node = PostgresNode()
         assert node._os_ops is not None
@@ -190,6 +245,10 @@ class TestTestgresCommon:
         with __class__.helper__get_node(node_svc) as node:
             # enable page checksums
             node.init(initdb_params=['-k']).start()
+        return
+
+    def test_custom_init__hba(self, node_svc: PostgresNodeService):
+        assert isinstance(node_svc, PostgresNodeService)
 
         with __class__.helper__get_node(node_svc) as node:
             node.init(
@@ -202,8 +261,24 @@ class TestTestgresCommon:
             # check number of lines
             assert (len(lines) >= 6)
 
+            # Normalize function: turns a string into a list of pure words
+            def normalize_line(line_str):
+                return line_str.strip().split()
+
+            # We collect a list of rules that already exist in the file (in the form of word lists)
+            existing_normalized = []
+            for s in lines:
+                s_clean = s.strip()
+                if s_clean and not s_clean.startswith("#"):
+                    existing_normalized.append(normalize_line(s_clean))
+                continue
+
             # there should be no trust entries at all
-            assert not (any('trust' in s for s in lines))
+            for s in lines:
+                if len(s) > 0 and s[0] in ["host", "local"]:
+                    assert s[-1] == "reject"
+                continue
+            return
 
     def test_double_init(self, node_svc: PostgresNodeService):
         assert isinstance(node_svc, PostgresNodeService)
@@ -1783,9 +1858,9 @@ class TestTestgresCommon:
             with removing(node_svc.os_ops, node1.dump(format=dump_fmt)) as dump:
                 with __class__.helper__get_node(node_svc).init().start() as node3:
                     if dump_fmt == enums.DumpFormat.Directory:
-                        assert (os.path.isdir(dump))
+                        assert (node_svc.os_ops.isdir(dump))
                     else:
-                        assert (os.path.isfile(dump))
+                        assert (node_svc.os_ops.isfile(dump))
                     # restore dump
                     node3.restore(filename=dump)
                     res = node3.execute(query_select)
@@ -1801,7 +1876,7 @@ class TestTestgresCommon:
             # Test dump with --schema-only option
             with removing(node_svc.os_ops, node1.dump(options=['--schema-only'])) as dump:
                 with __class__.helper__get_node(node_svc).init().start() as node2:
-                    assert (os.path.isfile(dump))
+                    assert (node_svc.os_ops.isfile(dump))
                     # restore schema-only dump
                     node2.restore(filename=dump)
 
@@ -2680,6 +2755,7 @@ where c.relname=%s;"""
         )
 
         assert node_app.os_ops is node_svc.os_ops
+        assert node_app.port_manager is not None
         assert node_app.port_manager is node_svc.port_manager
         assert type(node_app.nodes_to_cleanup) is list
         assert len(node_app.nodes_to_cleanup) == 0
@@ -2753,6 +2829,7 @@ where c.relname=%s;"""
                 assert not node._should_free_port
                 break
         finally:
+            assert node_app.port_manager is not None
             while len(ports) > 0:
                 node_app.port_manager.release_port(ports.pop())
 
@@ -2809,6 +2886,8 @@ where c.relname=%s;"""
 
             logging.info("Node is started ...")
             node.slow_start()
+
+            assert node.status() == NodeStatus.Running
         return
 
     @staticmethod

testgres-1.14.4/src/logger.py

@@ -1,49 +0,0 @@
-# coding: utf-8
-
-import logging
-import select
-import threading
-import time
-
-
-class TestgresLogger(threading.Thread):
-    """
-    Helper class to implement reading from log files.
-    """
-    def __init__(self, node_name, log_file_name):
-        threading.Thread.__init__(self)
-
-        self._node_name = node_name
-        self._log_file_name = log_file_name
-        self._stop_event = threading.Event()
-        self._logger = logging.getLogger(node_name)
-        self._logger.setLevel(logging.INFO)
-
-    def run(self):
-        # open log file for reading
-        with open(self._log_file_name, 'r') as fd:
-            # work until we're asked to stop
-            while not self._stop_event.is_set():
-                sleep_time = 0.1
-                new_lines = False
-
-                # do we have new lines?
-                if fd in select.select([fd], [], [], 0)[0]:
-                    for line in fd.readlines():
-                        line = line.strip()
-                        if line:
-                            new_lines = True
-                            extra = {'node': self._node_name}
-                            self._logger.info(line, extra=extra)
-
-                if not new_lines:
-                    time.sleep(sleep_time)
-
-            # don't forget to clear event
-            self._stop_event.clear()
-
-    def stop(self, wait=True):
-        self._stop_event.set()
-
-        if wait:
-            self.join()