docs: public FullResponseHolder go(
        Request request,
        HttpResponseHandler<FullResponseHolder, FullResponseHolder> responseHandler
    ) throws IOException, InterruptedException
    {
      Preconditions.checkState(lifecycleLock.awaitStarted(1, TimeUnit.MILLISECONDS));
      for (int counter = 0; counter < MAX_RETRIES; counter++) {
  
        final FullResponseHolder fullResponseHolder;
  
        try {
          try {
            fullResponseHolder = httpClient.go(request, responseHandler).get();
          }
          catch (ExecutionException e) {
            // Unwrap IOExceptions and ChannelExceptions, re-throw others
            Throwables.propagateIfInstanceOf(e.getCause(), IOException.class);
            Throwables.propagateIfInstanceOf(e.getCause(), ChannelException.class);
            throw new RE(e, "HTTP request to[%s] failed", request.getUrl());
          }
        }
        catch (IOException | ChannelException ex) {
          // can happen if the node is stopped.
          log.warn(ex, "Request[%s] failed.", request.getUrl());
  
          try {
            if (request.getUrl().getQuery() == null) {
              request = withUrl(
                  request,
                  new URL(StringUtils.format("%s%s", getCurrentKnownLeader(false), request.getUrl().getPath()))
              );
            } else {
              request = withUrl(
                  request,
                  new URL(StringUtils.format(
                      "%s%s?%s",
                      getCurrentKnownLeader(false),
                      request.getUrl().getPath(),
                      request.getUrl().getQuery()
                  ))
              );
            }
            continue;
          }
          catch (MalformedURLException e) {
            // Not an IOException; this is our own fault.
            throw new ISE(
                e,
                "failed to build url with path[%] and query string [%s].",
                request.getUrl().getPath(),
                request.getUrl().getQuery()
            );
          }
        }
  
        if (HttpResponseStatus.TEMPORARY_REDIRECT.equals(fullResponseHolder.getResponse().getStatus())) {
          String redirectUrlStr = fullResponseHolder.getResponse().headers().get("Location");
          if (redirectUrlStr == null) {
            throw new IOE("No redirect location is found in response from url[%s].", request.getUrl());
          }
  
          log.info("Request[%s] received redirect response to location [%s].", request.getUrl(), redirectUrlStr);
  
          final URL redirectUrl;
          try {
            redirectUrl = new URL(redirectUrlStr);
          }
          catch (MalformedURLException ex) {
            throw new IOE(
                ex,
                "Malformed redirect location is found in response from url[%s], new location[%s].",
                request.getUrl(),
                redirectUrlStr
            );
          }
  
          //update known leader location
          currentKnownLeader.set(StringUtils.format(
              "%s://%s:%s",
              redirectUrl.getProtocol(),
              redirectUrl.getHost(),
              redirectUrl.getPort()
          ));
  
          request = withUrl(request, redirectUrl);
        } else {
          return fullResponseHolder;
        }
      }
  
      throw new IOE("Retries exhausted, couldn't fulfill request to [%s].", request.getUrl());
    }