docs: def demote(self, mode):
          """Demote PostgreSQL running as master.
  
          :param mode: One of offline, graceful or immediate.
              offline is used when connection to DCS is not available.
              graceful is used when failing over to another node due to user request. May only be called running async.
              immediate is used when we determine that we are not suitable for master and want to failover quickly
                  without regard for data durability. May only be called synchronously.
              immediate-nolock is used when find out that we have lost the lock to be master. Need to bring down
                  PostgreSQL as quickly as possible without regard for data durability. May only be called synchronously.
          """
          mode_control = {
              'offline':          dict(stop='fast', checkpoint=False, release=False, offline=True, async_req=False),
              'graceful':         dict(stop='fast', checkpoint=True, release=True, offline=False, async_req=False),
              'immediate':        dict(stop='immediate', checkpoint=False, release=True, offline=False, async_req=True),
              'immediate-nolock': dict(stop='immediate', checkpoint=False, release=False, offline=False, async_req=True),
          }[mode]
  
          self.state_handler.trigger_check_diverged_lsn()
          self.state_handler.stop(mode_control['stop'], checkpoint=mode_control['checkpoint'],
                                  on_safepoint=self.watchdog.disable if self.watchdog.is_running else None)
          self.state_handler.set_role('demoted')
          self.set_is_leader(False)
  
          if mode_control['release']:
              with self._async_executor:
                  self.release_leader_key_voluntarily()
              time.sleep(2)  # Give a time to somebody to take the leader lock
          if mode_control['offline']:
              node_to_follow, leader = None, None
          else:
              cluster = self.dcs.get_cluster()
              node_to_follow, leader = self._get_node_to_follow(cluster), cluster.leader
  
          # FIXME: with mode offline called from DCS exception handler and handle_long_action_in_progress
          # there could be an async action already running, calling follow from here will lead
          # to racy state handler state updates.
          if mode_control['async_req']:
              self._async_executor.schedule('starting after demotion')
              self._async_executor.run_async(self.state_handler.follow, (node_to_follow,))
          else:
              if self.is_synchronous_mode():
                  self.state_handler.set_synchronous_standby(None)
              if self.state_handler.rewind_or_reinitialize_needed_and_possible(leader):
                  return False  # do not start postgres, but run pg_rewind on the next iteration
              self.state_handler.follow(node_to_follow)