docs: def create_replica(self, clone_member):
          """
              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
          """
  
          self.set_state('creating replica')
          self._sysid = None
  
          is_remote_master = isinstance(clone_member, RemoteMember)
          create_replica_methods = is_remote_master and clone_member.create_replica_methods
  
          # get list of replica methods either from clone member or from
          # the config. If there is no configuration key, or no value is
          # specified, use basebackup
          replica_methods = (
              create_replica_methods
              or self._create_replica_methods
              or ['basebackup']
          )
  
          if clone_member and clone_member.conn_url:
              r = clone_member.conn_kwargs(self._replication)
              connstring = 'postgres://{user}@{host}:{port}/{database}'.format(**r)
              # add the credentials to connect to the replica origin to pgpass.
              env = self.write_pgpass(r)
          else:
              connstring = ''
              env = os.environ.copy()
              # 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_replication_connection(r)]
  
          # go through them in priority order
          ret = 1
          for replica_method in replica_methods:
              with self._cancellable_lock:
                  if self._is_cancelled:
                      break
              # if the method is basebackup, then use the built-in
              if replica_method == "basebackup":
                  ret = self.basebackup(connstring, env, self.config.get(replica_method, {}))
                  if ret == 0:
                      logger.info("replica has been created using basebackup")
                      # if basebackup succeeds, exit with success
                      break
              else:
                  if not self.data_directory_empty():
                      if self.config.get(replica_method, {}).get('keep_data', False):
                          logger.info('Leaving data directory uncleaned')
                      else:
                          self.remove_data_directory()
  
                  cmd = replica_method
                  method_config = {}
                  # user-defined method; check for configuration
                  # not required, actually
                  if self.config.get(replica_method, {}):
                      method_config = self.config[replica_method].copy()
                      # look to see if the user has supplied a full command path
                      # if not, use the method name as the command
                      cmd = method_config.pop('command', cmd)
  
                  # add the default parameters
                  if not method_config.get('no_params', False):
                      method_config.update({"scope": self.scope,
                                            "role": "replica",
                                            "datadir": self._data_dir,
                                            "connstring": connstring})
                  else:
                      for param in ('no_params', 'no_master', 'keep_data'):
                          method_config.pop(param, None)
                  params = ["--{0}={1}".format(arg, val) for arg, val in method_config.items()]
                  try:
                      # call script with the full set of parameters
                      ret = self.cancellable_subprocess_call(shlex.split(cmd) + params, env=env)
                      # if we succeeded, stop
                      if ret == 0:
                          logger.info('replica has been created using %s', replica_method)
                          break
                      else:
                          logger.error('Error creating replica using method %s: %s exited with code=%s',
                                       replica_method, cmd, ret)
                  except Exception:
                      logger.exception('Error creating replica using method %s', replica_method)
                      ret = 1
  
          self.set_state('stopped')
          return ret