Variables and parameters renaming.

Previously, "without_leader" suffix was used in the name of methods
and functions that initialize a replica without an active replication
connection, and leader was part of the name for parameters and messages
that require an active replication conneciton. Since we support init
from the members other than the leader, those conventions have to be
changed.

patroni/ha.py

@@ -65,21 +65,25 @@ class Ha(object):
                 pass
         self.dcs.touch_member(json.dumps(data, separators=(',', ':')))
 
-    def clone(self, leader):
-        if self.state_handler.bootstrap(cluster_initialized=True, current_leader=leader):
-            logger.info('bootstrapped from leader' if leader else 'bootstrapped without leader')
+    def clone(self, clone_member, clone_member_name="leader"):
+        if self.state_handler.bootstrap(cluster_initialized=True, clone_member=clone_member):
+            logger.info('bootstrapped from {0}'.format(clone_member_name)
+                        if clone_member else 'bootstrapped without leader')
         else:
             self.state_handler.stop('immediate')
             self.state_handler.remove_data_directory()
-            logger.error('failed to bootstrap from leader' if leader else 'failed to bootstrap (without leader)')
+            logger.error('failed to bootstrap from {0}'.format(clone_member_name)
+                         if clone_member else 'failed to bootstrap (without leader)')
 
     def bootstrap(self):
         if not self.cluster.is_unlocked():  # cluster already has leader
-            self._async_executor.schedule('bootstrap from leader')
             clonefrom = self.patroni.clonefrom
-            source = self.cluster.get_member(clonefrom) if self.cluster.has_member(clonefrom) else self.cluster.leader
-            self._async_executor.run_async(self.clone, args=(source,))
-            return 'trying to bootstrap from leader'
+            clone_member = self.cluster.get_member(clonefrom)\
+                if self.cluster.has_member(clonefrom) else self.cluster.leader
+            clone_member_name = 'leader' if clone_member == self.cluster.leader else 'replica {0}'.format(clonefrom)
+            self._async_executor.schedule('bootstrap from {0}'.format(clone_member_name))
+            self._async_executor.run_async(self.clone, args=(clone_member, clone_member_name))
+            return 'trying to bootstrap from {0}'.format(clone_member_name)
         elif not self.cluster.initialize and not self.patroni.nofailover:  # no initialize key
             if self.dcs.initialize(create_new=True):  # race for initialization
                 try:
@@ -98,7 +102,7 @@ class Ha(object):
             else:
                 return 'failed to acquire initialize lock'
         else:
-            if self.state_handler.can_create_replica_without_leader():
+            if self.state_handler.can_create_replica_without_replication_connection():
                 self._async_executor.run_async(self.clone, args=(None, ))
                 return "trying to bootstrap without leader"
             return 'waiting for leader to bootstrap'

patroni/postgresql.py

@@ -233,10 +233,10 @@ class Postgresql(object):
         env['PGPASSFILE'] = self.pgpass
         return env
 
-    def sync_replica(self, leader):
-        # add either the leader's or replica's credentials to pgpass
-        env = self.write_pgpass(parseurl(leader.conn_url)) if leader else os.environ.copy()
-        if self.create_replica(leader, env) == 0:
+    def sync_replica(self, clone_member):
+        # add the credentials to connect to the replica origin to pgpass.
+        env = self.write_pgpass(parseurl(clone_member.conn_url)) if clone_member else os.environ.copy()
+        if self.create_replica(clone_member, env) == 0:
             self.delete_trigger_file()
             return True
         return False
@@ -249,33 +249,35 @@ class Postgresql(object):
         """
         return ' '.join('{0}={1}'.format(param, val) for param, val in sorted(conn.items()))
 
-    def replica_method_can_work_without_leader(self, method):
+    def replica_method_can_work_without_replication_connection(self, method):
         return method != 'basebackup' and self.config and self.config.get(method, {}).get('no_master')
 
-    def can_create_replica_without_leader(self):
+    def can_create_replica_without_replication_connection(self):
         """ go through the replication methods to see if there are ones
-            that does not require a running leader to create the replica.
+            that does not require a working replication connection.
         """
         replica_methods = self.config.get('create_replica_method', [])
-        return any(self.replica_method_can_work_without_leader(replica_method) for replica_method in replica_methods)
+        return any(self.replica_method_can_work_without_replication_connection(replica_method)
+                   for replica_method in replica_methods)
 
-    def create_replica(self, source, env):
+    def create_replica(self, clone_member, env):
         # create the replica according to the replica_method
         # defined by the user.  this is a list, so we need to
         # loop through all methods the user supplies
-        connstring = source.conn_url if source else ""
+        connstring = clone_member.conn_url if clone_member else ""
         # get list of replica methods from config.
         # If there is no configuration key, or no value is specified, use basebackup
         replica_methods = self.config.get('create_replica_method') or ['basebackup']
         # if we don't have any source, leave only replica methods that work without it
-        replica_methods = [r for r in replica_methods if self.replica_method_can_work_without_leader(r)] if not source \
-            else replica_methods
+        replica_methods = \
+            [r for r in replica_methods if self.replica_method_can_work_without_replication_connection(r)]\
+            if not clone_member else replica_methods
         # go through them in priority order
         ret = 1
         for replica_method in replica_methods:
             # if the method is basebackup, then use the built-in
             if replica_method == "basebackup":
-                ret = self.basebackup(source, env)
+                ret = self.basebackup(clone_member, env)
                 if ret == 0:
                     logger.info("replica has been created using basebackup")
                     # if basebackup succeeds, exit with success
@@ -699,18 +701,19 @@ $$""".format(name, options), name, password, password)
     def last_operation(self):
         return str(self.xlog_position())
 
-    def bootstrap(self, cluster_initialized=False, current_leader=None):
+    def bootstrap(self, cluster_initialized=False, clone_member=None):
         """
             Populate PostgreSQL data directory by doing one of the following:
              - create with initdb if there is no master.
-             - initialize the replica from an existing master or replica
+             - initialize the replica from an existing member (master or replica)
              - initialize the replica using the replica creation method that
-               works without the master (i.e. restore from on-disk base backup)
+               works without the replication connection (i.e. restore from on-disk
+               base backup)
 
             The choice between the last 2 is triggered by the initialize flag.
             We should never try to initdb an already initialized cluster, nor
-            try to bootstrap the cluster that lacks the initialize key from from
-            the master-less replica creation method (in the latter case, there is
+            try to bootstrap the cluster that lacks the initialize key using the
+            master-less replica creation method (in the latter case, there is
             no clear inidicator of the moment we should abandon our attempts and
             swich to initdb).
 
@@ -720,7 +723,7 @@ $$""".format(name, options), name, password, password)
             that should be retried in the future.
         """
         ret = False
-        if not (cluster_initialized or current_leader):
+        if not (cluster_initialized or clone_member):
             ret = self.initialize() and self.start()
             if ret:
                 self.create_replication_user()
@@ -728,9 +731,9 @@ $$""".format(name, options), name, password, password)
             else:
                 raise PostgresException("Could not bootstrap master PostgreSQL")
         else:
-            if self.sync_replica(current_leader):
+            if self.sync_replica(clone_member):
                 self.restore_configuration_files()
-                self.write_recovery_conf(current_leader, True)
+                self.write_recovery_conf(clone_member, True)
                 ret = self.start()
         return ret
 
@@ -758,12 +761,12 @@ $$""".format(name, options), name, password, password)
             logger.exception('Could not remove data directory %s', self.data_dir)
             self.move_data_directory()
 
-    def basebackup(self, leader, env):
+    def basebackup(self, clone_member, env):
         # creates a replica data dir using pg_basebackup.
         # this is the default, built-in create_replica_method
         # tries twice, then returns failure (as 1)
         # uses "stream" as the xlog-method to avoid sync issues
-        master_connection = leader.conn_url
+        master_connection = clone_member.conn_url
         maxfailures = 2
         ret = 1
         for bbfailures in range(0, maxfailures):

tests/test_ha.py

@@ -88,7 +88,7 @@ class TestHa(unittest.TestCase):
                                  'replication': {'username': '', 'password': '', 'network': ''}})
             self.p.set_state('running')
             self.p.check_replication_lag = true
-            self.p.can_create_replica_without_leader = MagicMock(return_value=False)
+            self.p.can_create_replica_without_replication_connection = MagicMock(return_value=False)
             self.e = Etcd('foo', {'ttl': 30, 'host': 'ok:2379', 'scope': 'test'})
             self.e.client.read = etcd_read
             self.e.client.write = etcd_write
@@ -212,7 +212,7 @@ class TestHa(unittest.TestCase):
 
     def test_bootstrap_without_leader(self):
         self.ha.cluster = get_cluster_initialized_without_leader()
-        self.p.can_create_replica_without_leader = MagicMock(return_value=True)
+        self.p.can_create_replica_without_replication_connection = MagicMock(return_value=True)
         self.assertEquals(self.ha.bootstrap(), "trying to bootstrap without leader")
 
     def test_bootstrap_initialize_lock_failed(self):

tests/test_postgresql.py

@@ -471,17 +471,17 @@ class TestPostgresql(unittest.TestCase):
     def test_restore_configuration_files(self):
         self.p.restore_configuration_files()
 
-    def test_can_create_replica_without_leader(self):
+    def test_can_create_replica_without_replication_connection(self):
         self.p.config['create_replica_method'] = []
-        self.assertFalse(self.p.can_create_replica_without_leader())
+        self.assertFalse(self.p.can_create_replica_without_replication_connection())
         self.p.config['create_replica_method'] = ['wale', 'basebackup']
         self.p.config['wale'] = {'command': 'foo', 'no_master': 1}
-        self.assertTrue(self.p.can_create_replica_without_leader())
+        self.assertTrue(self.p.can_create_replica_without_replication_connection())
 
-    def test_replica_method_can_work_without_leader(self):
-        self.assertFalse(self.p.replica_method_can_work_without_leader('basebackup'))
-        self.assertFalse(self.p.replica_method_can_work_without_leader('foobar'))
+    def test_replica_method_can_work_without_replication_connection(self):
+        self.assertFalse(self.p.replica_method_can_work_without_replication_connection('basebackup'))
+        self.assertFalse(self.p.replica_method_can_work_without_replication_connection('foobar'))
         self.p.config['foo'] = {'command': 'bar', 'no_master': 1}
-        self.assertTrue(self.p.replica_method_can_work_without_leader('foo'))
+        self.assertTrue(self.p.replica_method_can_work_without_replication_connection('foo'))
         self.p.config['foo'] = {'command': 'bar'}
-        self.assertFalse(self.p.replica_method_can_work_without_leader('foo'))
+        self.assertFalse(self.p.replica_method_can_work_without_replication_connection('foo'))