testgres 1.11.0__tar.gz → 1.11.1__tar.gz

{testgres-1.11.0/testgres.egg-info → testgres-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.11.0
+Version: 1.11.1
 Summary: Testing utility for PostgreSQL and its extensions
 Home-page: https://github.com/postgrespro/testgres
 Author: Postgres Professional
@@ -33,7 +33,7 @@ Dynamic: summary
 
 # testgres
 
-PostgreSQL testing utility. Both Python 2.7 and 3.3+ are supported.
+PostgreSQL testing utility. Python 3.7.17+ is supported.
 
 
 ## Installation

{testgres-1.11.0 → testgres-1.11.1}/README.md

@@ -6,7 +6,7 @@
 
 # testgres
 
-PostgreSQL testing utility. Both Python 2.7 and 3.3+ are supported.
+PostgreSQL testing utility. Python 3.7.17+ is supported.
 
 
 ## Installation

{testgres-1.11.0 → testgres-1.11.1}/setup.py

@@ -27,9 +27,9 @@ with open('README.md', 'r') as f:
     readme = f.read()
 
 setup(
-    version='1.11.0',
+    version='1.11.1',
     name='testgres',
-    packages=['testgres', 'testgres.operations'],
+    packages=['testgres', 'testgres.operations', 'testgres.impl'],
     description='Testing utility for PostgreSQL and its extensions',
     url='https://github.com/postgrespro/testgres',
     long_description=readme,

{testgres-1.11.0 → testgres-1.11.1}/testgres/__init__.py

@@ -33,8 +33,9 @@ from .enums import \
     ProcessType, \
     DumpFormat
 
-from .node import PostgresNode, NodeApp
+from .node import PostgresNode
 from .node import PortManager
+from .node_app import NodeApp
 
 from .utils import \
     reserve_port, \
@@ -62,8 +63,9 @@ __all__ = [
     "NodeConnection", "DatabaseError", "InternalError", "ProgrammingError", "OperationalError",
     "TestgresException", "ExecUtilException", "QueryException", "TimeoutException", "CatchUpException", "StartNodeException", "InitNodeException", "BackupException", "InvalidOperationException",
     "XLogMethod", "IsolationLevel", "NodeStatus", "ProcessType", "DumpFormat",
-    "PostgresNode", "NodeApp",
-    "PortManager",
+    NodeApp.__name__,
+    PostgresNode.__name__,
+    PortManager.__name__,
     "reserve_port", "release_port", "bound_ports", "get_bin_path", "get_pg_config", "get_pg_version",
     "First", "Any",
     "OsOperations", "LocalOperations", "RemoteOperations", "ConnectionParams"

{testgres-1.11.0 → testgres-1.11.1}/testgres/backup.py

@@ -1,7 +1,5 @@
 # coding: utf-8
 
-import os
-
 from six import raise_from
 
 from .enums import XLogMethod
@@ -29,7 +27,9 @@ class NodeBackup(object):
     """
     @property
     def log_file(self):
-        return os.path.join(self.base_dir, BACKUP_LOG_FILE)
+        assert self.os_ops is not None
+        assert isinstance(self.os_ops, OsOperations)
+        return self.os_ops.build_path(self.base_dir, BACKUP_LOG_FILE)
 
     def __init__(self,
                  node,
@@ -75,7 +75,7 @@ class NodeBackup(object):
         # private
         self._available = True
 
-        data_dir = os.path.join(self.base_dir, DATA_DIR)
+        data_dir = self.os_ops.build_path(self.base_dir, DATA_DIR)
 
         _params = [
             get_bin_path2(self.os_ops, "pg_basebackup"),
@@ -112,10 +112,13 @@ class NodeBackup(object):
         available = not destroy
 
         if available:
+            assert self.os_ops is not None
+            assert isinstance(self.os_ops, OsOperations)
+
             dest_base_dir = self.os_ops.mkdtemp(prefix=TMP_NODE)
 
-            data1 = os.path.join(self.base_dir, DATA_DIR)
-            data2 = os.path.join(dest_base_dir, DATA_DIR)
+            data1 = self.os_ops.build_path(self.base_dir, DATA_DIR)
+            data2 = self.os_ops.build_path(dest_base_dir, DATA_DIR)
 
             try:
                 # Copy backup to new data dir
@@ -160,10 +163,6 @@ class NodeBackup(object):
         assert type(node) == self.original_node.__class__  # noqa: E721
 
         with clean_on_error(node) as node:
-
-            # New nodes should always remove dir tree
-            node._should_rm_dirs = True
-
             # Set a new port
             node.append_conf(filename=PG_CONF_FILE, line='\n')
             node.append_conf(filename=PG_CONF_FILE, port=node.port)
@@ -184,14 +183,19 @@ class NodeBackup(object):
         """
 
         # Build a new PostgresNode
-        with clean_on_error(self.spawn_primary(name=name,
-                                               destroy=destroy)) as node:
+        node = self.spawn_primary(name=name, destroy=destroy)
+        assert node is not None
 
+        try:
             # Assign it a master and a recovery file (private magic)
             node._assign_master(self.original_node)
             node._create_recovery_conf(username=self.username, slot=slot)
+        except:  # noqa: E722
+            # TODO: Pass 'final=True' ?
+            node.cleanup(release_resources=True)
+            raise
 
-            return node
+        return node
 
     def cleanup(self):
         """

{testgres-1.11.0 → testgres-1.11.1}/testgres/cache.py

@@ -1,7 +1,5 @@
 # coding: utf-8
 
-import os
-
 from six import raise_from
 
 from .config import testgres_config
@@ -22,12 +20,16 @@ from .operations.local_ops import LocalOperations
 from .operations.os_ops import OsOperations
 
 
-def cached_initdb(data_dir, logfile=None, params=None, os_ops: OsOperations = LocalOperations(), bin_path=None, cached=True):
+def cached_initdb(data_dir, logfile=None, params=None, os_ops: OsOperations = None, bin_path=None, cached=True):
     """
     Perform initdb or use cached node files.
     """
 
-    assert os_ops is not None
+    assert os_ops is None or isinstance(os_ops, OsOperations)
+
+    if os_ops is None:
+        os_ops = LocalOperations.get_single_instance()
+
     assert isinstance(os_ops, OsOperations)
 
     def make_utility_path(name):
@@ -35,7 +37,7 @@ def cached_initdb(data_dir, logfile=None, params=None, os_ops: OsOperations = Lo
         assert type(name) == str  # noqa: E721
 
         if bin_path:
-            return os.path.join(bin_path, name)
+            return os_ops.build_path(bin_path, name)
 
         return get_bin_path2(os_ops, name)
 
@@ -68,7 +70,7 @@ def cached_initdb(data_dir, logfile=None, params=None, os_ops: OsOperations = Lo
                 # XXX: write new unique system id to control file
                 # Some users might rely upon unique system ids, but
                 # our initdb caching mechanism breaks this contract.
-                pg_control = os.path.join(data_dir, XLOG_CONTROL_FILE)
+                pg_control = os_ops.build_path(data_dir, XLOG_CONTROL_FILE)
                 system_id = generate_system_id()
                 cur_pg_control = os_ops.read(pg_control, binary=True)
                 new_pg_control = system_id + cur_pg_control[len(system_id):]

{testgres-1.11.0 → testgres-1.11.1}/testgres/config.py

@@ -50,8 +50,9 @@ class GlobalConfig(object):
     _cached_initdb_dir = None
     """ underlying class attribute for cached_initdb_dir property """
 
-    os_ops = LocalOperations()
+    os_ops = LocalOperations.get_single_instance()
     """ OsOperation object that allows work on remote host """
+
     @property
     def cached_initdb_dir(self):
         """ path to a temp directory for cached initdb. """

testgres-1.11.0/testgres/port_manager.py → testgres-1.11.1/testgres/impl/port_manager__generic.py

@@ -1,53 +1,18 @@
-from .operations.os_ops import OsOperations
+from ..operations.os_ops import OsOperations
 
-from .exceptions import PortForException
-
-from . import utils
+from ..port_manager import PortManager
+from ..exceptions import PortForException
 
 import threading
 import random
 import typing
-
-
-class PortManager:
-    def __init__(self):
-        super().__init__()
-
-    def reserve_port(self) -> int:
-        raise NotImplementedError("PortManager::reserve_port is not implemented.")
-
-    def release_port(self, number: int) -> None:
-        assert type(number) == int  # noqa: E721
-        raise NotImplementedError("PortManager::release_port is not implemented.")
-
-
-class PortManager__ThisHost(PortManager):
-    sm_single_instance: PortManager = None
-    sm_single_instance_guard = threading.Lock()
-
-    def __init__(self):
-        pass
-
-    def __new__(cls) -> PortManager:
-        assert __class__ == PortManager__ThisHost
-        assert __class__.sm_single_instance_guard is not None
-
-        if __class__.sm_single_instance is None:
-            with __class__.sm_single_instance_guard:
-                __class__.sm_single_instance = super().__new__(cls)
-        assert __class__.sm_single_instance
-        assert type(__class__.sm_single_instance) == __class__  # noqa: E721
-        return __class__.sm_single_instance
-
-    def reserve_port(self) -> int:
-        return utils.reserve_port()
-
-    def release_port(self, number: int) -> None:
-        assert type(number) == int  # noqa: E721
-        return utils.release_port(number)
+import logging
 
 
 class PortManager__Generic(PortManager):
+    _C_MIN_PORT_NUMBER = 1024
+    _C_MAX_PORT_NUMBER = 65535
+
     _os_ops: OsOperations
     _guard: object
     # TODO: is there better to use bitmap fot _available_ports?
@@ -55,12 +20,21 @@ class PortManager__Generic(PortManager):
     _reserved_ports: typing.Set[int]
 
     def __init__(self, os_ops: OsOperations):
+        assert __class__._C_MIN_PORT_NUMBER <= __class__._C_MAX_PORT_NUMBER
+
         assert os_ops is not None
         assert isinstance(os_ops, OsOperations)
         self._os_ops = os_ops
         self._guard = threading.Lock()
-        self._available_ports: typing.Set[int] = set(range(1024, 65535))
-        self._reserved_ports: typing.Set[int] = set()
+
+        self._available_ports = set(
+            range(__class__._C_MIN_PORT_NUMBER, __class__._C_MAX_PORT_NUMBER + 1)
+        )
+        assert len(self._available_ports) == (
+            (__class__._C_MAX_PORT_NUMBER - __class__._C_MIN_PORT_NUMBER) + 1
+        )
+        self._reserved_ports = set()
+        return
 
     def reserve_port(self) -> int:
         assert self._guard is not None
@@ -74,9 +48,13 @@ class PortManager__Generic(PortManager):
             t = None
 
             for port in sampled_ports:
+                assert type(port) == int  # noqa: E721
                 assert not (port in self._reserved_ports)
                 assert port in self._available_ports
 
+                assert port >= __class__._C_MIN_PORT_NUMBER
+                assert port <= __class__._C_MAX_PORT_NUMBER
+
                 if not self._os_ops.is_port_free(port):
                     continue
 
@@ -84,12 +62,15 @@ class PortManager__Generic(PortManager):
                 self._available_ports.discard(port)
                 assert port in self._reserved_ports
                 assert not (port in self._available_ports)
+                __class__.helper__send_debug_msg("Port {} is reserved.", port)
                 return port
 
         raise PortForException("Can't select a port.")
 
     def release_port(self, number: int) -> None:
         assert type(number) == int  # noqa: E721
+        assert number >= __class__._C_MIN_PORT_NUMBER
+        assert number <= __class__._C_MAX_PORT_NUMBER
 
         assert self._guard is not None
         assert type(self._reserved_ports) == set  # noqa: E721
@@ -101,3 +82,16 @@ class PortManager__Generic(PortManager):
             self._reserved_ports.discard(number)
             assert not (number in self._reserved_ports)
             assert number in self._available_ports
+            __class__.helper__send_debug_msg("Port {} is released.", number)
+        return
+
+    @staticmethod
+    def helper__send_debug_msg(msg_template: str, *args) -> None:
+        assert msg_template is not None
+        assert args is not None
+        assert type(msg_template) == str  # noqa: E721
+        assert type(args) == tuple  # noqa: E721
+        assert msg_template != ""
+        s = "[port manager] "
+        s += msg_template.format(*args)
+        logging.debug(s)

testgres-1.11.1/testgres/impl/port_manager__this_host.py

@@ -0,0 +1,33 @@
+from ..port_manager import PortManager
+
+from .. import utils
+
+import threading
+
+
+class PortManager__ThisHost(PortManager):
+    sm_single_instance: PortManager = None
+    sm_single_instance_guard = threading.Lock()
+
+    @staticmethod
+    def get_single_instance() -> PortManager:
+        assert __class__ == PortManager__ThisHost
+        assert __class__.sm_single_instance_guard is not None
+
+        if __class__.sm_single_instance is not None:
+            assert type(__class__.sm_single_instance) == __class__  # noqa: E721
+            return __class__.sm_single_instance
+
+        with __class__.sm_single_instance_guard:
+            if __class__.sm_single_instance is None:
+                __class__.sm_single_instance = __class__()
+        assert __class__.sm_single_instance is not None
+        assert type(__class__.sm_single_instance) == __class__  # noqa: E721
+        return __class__.sm_single_instance
+
+    def reserve_port(self) -> int:
+        return utils.reserve_port()
+
+    def release_port(self, number: int) -> None:
+        assert type(number) == int  # noqa: E721
+        return utils.release_port(number)