generate application name if asked to

Author: funbringer

README.md

@@ -54,8 +54,8 @@ import logging
 logging.basicConfig(filename='/tmp/testgres.log')
 
 # create two different nodes with logging
-node1 = testgres.get_new_node('node1', use_logging=True).init().start()
-node2 = testgres.get_new_node('node2', use_logging=True).init().start()
+node1 = testgres.get_new_node(use_logging=True).init().start()
+node2 = testgres.get_new_node(use_logging=True).init().start()
 
 # execute a few queries
 node1.execute('postgres', 'select 1')
@@ -87,7 +87,7 @@ or
 with testgres.get_new_node('master', '/path/to/DB') as node:
 ```
 
-where `master` is a node's name, not a DB's name. Name matters if you're testing something like replication.
+where `master` is a node's application name. Name matters if you're testing something like replication.
 Function `get_new_node()` only creates directory structure in specified directory (or somewhere in '/tmp' if
 we did not specify base directory) for cluster. After that, we have to initialize the PostgreSQL cluster:
 

testgres/api.py

@@ -7,7 +7,7 @@
 edit configuration files, start/stop cluster, execute queries. The
 typical flow may look like:
 
-    with get_new_node('test') as node:
+    with get_new_node() as node:
         node.init()
         node.start()
         result = node.psql('postgres', 'SELECT 1')
@@ -16,10 +16,10 @@
 
     Or:
 
-    with get_new_node('node1') as node1:
+    with get_new_node() as node1:
         node1.init().start()
         with node1.backup() as backup:
-            with backup.spawn_primary('node2') as node2:
+            with backup.spawn_primary() as node2:
                 res = node2.start().execute('postgres', 'select 2')
                 print(res)
 
@@ -29,12 +29,12 @@
 from .node import PostgresNode
 
 
-def get_new_node(name, base_dir=None, use_logging=False):
+def get_new_node(name=None, base_dir=None, use_logging=False):
     """
     Create a new node (select port automatically).
 
     Args:
-        name: node's name.
+        name: node's application name.
         base_dir: path to node's data directory.
         use_logging: enable python logging.
 

testgres/backup.py

@@ -114,28 +114,27 @@ def _prepare_dir(self, destroy):
         # Return path to new node
         return dest_base_dir
 
-    def spawn_primary(self, name, destroy=True, use_logging=False):
+    def spawn_primary(self, name=None, destroy=True, use_logging=False):
         """
         Create a primary node from a backup.
 
         Args:
-            name: name for a new node.
+            name: primary's application name.
             destroy: should we convert this backup into a node?
             use_logging: enable python logging.
 
         Returns:
             New instance of PostgresNode.
         """
 
+        # Prepare a data directory for this node
         base_dir = self._prepare_dir(destroy)
 
         # Build a new PostgresNode
         from .node import PostgresNode
-        node = PostgresNode(
-            name=name,
-            base_dir=base_dir,
-            master=self.original_node,
-            use_logging=use_logging)
+        node = PostgresNode(name=name,
+                            base_dir=base_dir,
+                            use_logging=use_logging)
 
         # New nodes should always remove dir tree
         node._should_rm_dirs = True
@@ -145,22 +144,27 @@ def spawn_primary(self, name, destroy=True, use_logging=False):
 
         return node
 
-    def spawn_replica(self, name, destroy=True, use_logging=False):
+    def spawn_replica(self, name=None, destroy=True, use_logging=False):
         """
         Create a replica of the original node from a backup.
 
         Args:
-            name: name for a new node.
+            name: replica's application name.
             destroy: should we convert this backup into a node?
             use_logging: enable python logging.
 
         Returns:
             New instance of PostgresNode.
         """
 
-        node = self.spawn_primary(name, destroy, use_logging=use_logging)
-        node._create_recovery_conf(username=self.username,
-                                   master=self.original_node)
+        # Build a new PostgresNode
+        node = self.spawn_primary(name=name,
+                                  destroy=destroy,
+                                  use_logging=use_logging)
+
+        # Assign it a master and a recovery file (private magic)
+        node._assign_master(self.original_node)
+        node._create_recovery_conf(username=self.username)
 
         return node
 

testgres/node.py

@@ -41,6 +41,7 @@
     reserve_port as _reserve_port, \
     release_port as _release_port, \
     default_username as _default_username, \
+    generate_app_name as _generate_app_name, \
     execute_utility as _execute_utility
 
 
@@ -60,18 +61,23 @@ def __bool__(self):
 
 
 class PostgresNode(object):
-    def __init__(self,
-                 name,
-                 port=None,
-                 base_dir=None,
-                 use_logging=False,
-                 master=None):
+    def __init__(self, name=None, port=None, base_dir=None, use_logging=False):
+        """
+        Create a new node manually.
+
+        Args:
+            name: node's application name.
+            port: port to accept connections.
+            base_dir: path to node's data directory.
+            use_logging: enable python logging.
+        """
+
         global bound_ports
 
         # public
-        self.master = master
-        self.name = name
+        self.master = None
         self.host = '127.0.0.1'
+        self.name = name or _generate_app_name()
         self.port = port or _reserve_port()
         self.base_dir = base_dir
 
@@ -112,7 +118,14 @@ def utils_log_name(self):
     def pg_log_name(self):
         return os.path.join(self.logs_dir, _PG_LOG_FILE)
 
-    def _create_recovery_conf(self, username, master):
+    def _assign_master(self, master):
+        # now this node has a master
+        self.master = master
+
+    def _create_recovery_conf(self, username):
+        # fetch master of this node
+        master = self.master
+
         # yapf: disable
         conninfo = (
             u"application_name={} "
@@ -785,22 +798,25 @@ def backup(self, username=None, xlog_method=_DEFAULT_XLOG_METHOD):
         return NodeBackup(node=self, username=username, xlog_method=xlog_method)
 
     def replicate(self,
-                  name,
+                  name=None,
                   username=None,
                   xlog_method=_DEFAULT_XLOG_METHOD,
                   use_logging=False):
         """
         Create a binary replica of this node.
 
         Args:
-            name: replica's name.
+            name: replica's application name.
             username: database user name.
             xlog_method: a method for collecting the logs ('fetch' | 'stream').
             use_logging: enable python logging.
         """
 
+        # transform backup into a replica
         backup = self.backup(username=username, xlog_method=xlog_method)
-        return backup.spawn_replica(name=name, use_logging=use_logging)
+        return backup.spawn_replica(name=name,
+                                    destroy=True,
+                                    use_logging=use_logging)
 
     def catchup(self, dbname='postgres', username=None):
         """

testgres/utils.py

@@ -47,6 +47,15 @@ def default_username():
     return pwd.getpwuid(os.getuid())[0]
 
 
+def generate_app_name():
+    """
+    Generate a new application name for node.
+    """
+
+    import uuid
+    return ''.join(['testgres-', str(uuid.uuid4())])
+
+
 def execute_utility(args, logfile):
     """
     Execute utility (pg_ctl, pg_dump etc).

tests/test_simple.py

@@ -602,6 +602,21 @@ def test_unix_sockets(self):
             r.execute('postgres', 'select 1')
             r.safe_psql('postgres', 'select 1')
 
+    def test_auto_name(self):
+        with get_new_node().init(allow_streaming=True).start() as m:
+            with m.replicate().start() as r:
+
+                # check that nodes are running
+                self.assertTrue(m.status())
+                self.assertTrue(r.status())
+
+                # check their names
+                self.assertIsNotNone(m.name)
+                self.assertIsNotNone(r.name)
+                self.assertNotEqual(m.name, r.name)
+                self.assertTrue('testgres' in m.name)
+                self.assertTrue('testgres' in r.name)
+
     def test_isolation_levels(self):
         with get_new_node('node').init().start() as node:
             with node.connect() as con: