code: def _send_broker_unaware_request(self, requestId, request):
          
          node_ids = list(self._brokers.keys())
          # Randomly shuffle the brokers to distribute the load
          random.shuffle(node_ids)
  
          # Prioritize connected brokers
          def connected(node_id):
              try:
                  return self.clients[node_id].connected()
              except KeyError:
                  return False
  
          node_ids.sort(reverse=True, key=connected)
  
          for node_id in node_ids:
              broker = self._get_brokerclient(node_id)
              try:
                  log.debug('_sbur: sending request %d to broker %r', requestId, broker)
                  d = self._make_request_to_broker(broker, requestId, request)
                  resp = yield d
                  returnValue(resp)
              except KafkaError as e:
                  log.warning((
                      "Will try next server after request with correlationId=%d"
                      " failed against server %s:%i. Error: %s"
                  ), requestId, broker.host, broker.port, e)
  
          # The request was not handled, likely because no broker metadata has
          # loaded yet (or all broker connections have failed). Fall back to
          # boostrapping.
          returnValue((yield self._send_bootstrap_request(request)))
docs: Attempt to send a broker-agnostic request to one of the known brokers:
  
          1. Try each connected broker (in random order)
          2. Try each known but unconnected broker (in random order)
          3. Try each of the bootstrap hosts (in random order)
  
          :param bytes request:
              The bytes of a Kafka `RequestMessage`_ structure. It must have
              a unique (to this connection) correlation ID.
  
          :returns: API response message for *request*
          :rtype: Deferred[bytes]
  
          :raises:
              `KafkaUnavailableError` when making the request of all known hosts
              has failed.