docs: def process_sync_replication(self):
          """Process synchronous standby beahvior.
  
          Synchronous standbys are registered in two places postgresql.conf and DCS. The order of updating them must
          be right. The invariant that should be kept is that if a node is master and sync_standby is set in DCS,
          then that node must have synchronous_standby set to that value. Or more simple, first set in postgresql.conf
          and then in DCS. When removing, first remove in DCS, then in postgresql.conf. This is so we only consider
          promoting standbys that were guaranteed to be replicating synchronously.
          """
          if self.is_synchronous_mode():
              current = self.cluster.sync.leader and self.cluster.sync.sync_standby
              picked, allow_promote = self.state_handler.pick_synchronous_standby(self.cluster)
              if picked != current:
                  # We need to revoke privilege from current before replacing it in the config
                  if current:
                      logger.info("Removing synchronous privilege from %s", current)
                      if not self.dcs.write_sync_state(self.state_handler.name, None, index=self.cluster.sync.index):
                          logger.info('Synchronous replication key updated by someone else.')
                          return
  
                  if self.is_synchronous_mode_strict() and picked is None:
                      picked = '*'
                      logger.warning("No standbys available!")
  
                  logger.info("Assigning synchronous standby status to %s", picked)
                  self.state_handler.set_synchronous_standby(picked)
  
                  if picked and picked != '*' and not allow_promote:
                      # Wait for PostgreSQL to enable synchronous mode and see if we can immediately set sync_standby
                      time.sleep(2)
                      picked, allow_promote = self.state_handler.pick_synchronous_standby(self.cluster)
                  if allow_promote:
                      try:
                          cluster = self.dcs.get_cluster()
                      except DCSError:
                          return logger.warning("Could not get cluster state from DCS during process_sync_replication()")
                      if cluster.sync.leader and cluster.sync.leader != self.state_handler.name:
                          logger.info("Synchronous replication key updated by someone else")
                          return
                      if not self.dcs.write_sync_state(self.state_handler.name, picked, index=cluster.sync.index):
                          logger.info("Synchronous replication key updated by someone else")
                          return
                      logger.info("Synchronous standby status assigned to %s", picked)
          else:
              if self.cluster.sync.leader and self.dcs.delete_sync_state(index=self.cluster.sync.index):
                  logger.info("Disabled synchronous replication")
              self.state_handler.set_synchronous_standby(None)