docs: def start(self, timeout=None, task=None, block_callbacks=False, role=None):
          """Start PostgreSQL
  
          Waits for postmaster to open ports or terminate so pg_isready can be used to check startup completion
          or failure.
  
          :returns: True if start was initiated and postmaster ports are open, False if start failed"""
          # make sure we close all connections established against
          # the former node, otherwise, we might get a stalled one
          # after kill -9, which would report incorrect data to
          # patroni.
          self.close_connection()
  
          if self.is_running():
              logger.error('Cannot start PostgreSQL because one is already running.')
              self.set_state('starting')
              return True
  
          if not block_callbacks:
              self.__cb_pending = ACTION_ON_START
  
          self.set_role(role or self.get_postgres_role_from_data_directory())
  
          self.set_state('starting')
          self._pending_restart = False
  
          configuration = self._server_parameters if self.role == 'master' else self._build_effective_configuration()
          self._write_postgresql_conf(configuration)
          self.resolve_connection_addresses()
          self._replace_pg_hba()
          self._replace_pg_ident()
  
          options = ['--{0}={1}'.format(p, configuration[p]) for p in self.CMDLINE_OPTIONS
                     if p in configuration and p != 'wal_keep_segments']
  
          with self._cancellable_lock:
              if self._is_cancelled:
                  return False
  
          with task or null_context():
              if task and task.is_cancelled:
                  logger.info("PostgreSQL start cancelled.")
                  return False
  
              self._postmaster_proc = PostmasterProcess.start(self._pgcommand('postgres'),
                                                              self._data_dir,
                                                              self._postgresql_conf,
                                                              options)
  
              if task:
                  task.complete(self._postmaster_proc)
  
          start_timeout = timeout
          if not start_timeout:
              try:
                  start_timeout = float(self.config.get('pg_ctl_timeout', 60))
              except ValueError:
                  start_timeout = 60
  
          # We want postmaster to open ports before we continue
          if not self._postmaster_proc or not self.wait_for_port_open(self._postmaster_proc, start_timeout):
              return False
  
          ret = self.wait_for_startup(start_timeout)
          if ret is not None:
              return ret
          elif timeout is not None:
              return False
          else:
              return None