docs: private void negotiateJobSettingsWithServers() {
          // 1. Get block-level compression settings
  
          // FIXME: Currently this code requests only one cluster for its supported compression codec.
          log.info("Requesting block-level compression codec expected by Server");
          String chosenCodec = null;
          List<String> supportedCodecs;
          try{
              supportedCodecs = adminClientPerCluster.get(clusterURLs.get(0))
                      .readonlyOps.getSupportedROStorageCompressionCodecs();
  
              String codecList = "[ ";
              for(String str: supportedCodecs) {
                  codecList += str + " ";
              }
              codecList += "]";
              log.info("Server responded with block-level compression codecs: " + codecList);
              /*
               * TODO for now only checking if there is a match between the server
               * supported codec and the one that we support. Later this method can be
               * extended to add more compression types or pick the first type
               * returned by the server.
               */
  
              for(String codecStr: supportedCodecs) {
                  if(codecStr.toUpperCase(Locale.ENGLISH).equals(KeyValueWriter.COMPRESSION_CODEC)) {
                      chosenCodec = codecStr;
                      break;
                  }
              }
          } catch(Exception e) {
              log.error("Exception thrown when requesting for supported block-level compression codecs. " +
                        "Server might be running in a older version. Exception: " + e.getMessage());
              // We will continue without block-level compression enabled
          }
  
          if(chosenCodec != null) {
              log.info("Using block-level compression codec: " + chosenCodec);
              this.props.put(REDUCER_OUTPUT_COMPRESS, "true");
              this.props.put(REDUCER_OUTPUT_COMPRESS_CODEC, chosenCodec);
          } else {
              log.info("Using no block-level compression");
          }
  
          // 2. Get High-Availability settings
  
          this.haSettingsPerCluster = Maps.newHashMap();
          if (!pushHighAvailability) {
              log.info("pushHighAvailability is disabled by the job config.");
          } else {
              // HA is enabled by the BnP job config
              for (String clusterUrl: clusterURLs) {
                  try {
                      VAdminProto.GetHighAvailabilitySettingsResponse serverSettings =
                              adminClientPerCluster.get(clusterUrl).readonlyOps.getHighAvailabilitySettings();
                      this.haSettingsPerCluster.put(clusterUrl, serverSettings);
                  } catch (UninitializedMessageException e) {
                      // Not printing out the exception in the logs as that is a benign error.
                      log.error("The server does not support HA (introduced in release 1.9.20), so " +
                                "pushHighAvailability will be DISABLED on cluster: " + clusterUrl);
                  } catch (Exception e) {
                      log.error("Got exception while trying to determine pushHighAvailability settings on cluster: " + clusterUrl, e);
                  }
              }
          }
  
          // 3. Get "build.primary.replicas.only" setting
  
          Map<String, String> expectedConfig = Maps.newHashMap();
          expectedConfig.put(VoldemortConfig.READONLY_BUILD_PRIMARY_REPLICAS_ONLY, Boolean.toString(true));
          this.buildPrimaryReplicasOnly = true;
          for (String clusterUrl: clusterURLs) {
              VAdminProto.GetHighAvailabilitySettingsResponse serverSettings = haSettingsPerCluster.get(clusterUrl);
              int maxNodeFailuresForCluster = 0;
              if (serverSettings != null) {
                  maxNodeFailuresForCluster = serverSettings.getMaxNodeFailure();
              }
              if (!adminClientPerCluster.get(clusterUrl).metadataMgmtOps.validateServerConfig(expectedConfig, maxNodeFailuresForCluster)) {
                  log.info("'" + BUILD_PRIMARY_REPLICAS_ONLY + "' is not supported on this destination cluster: " + clusterUrl);
                  this.buildPrimaryReplicasOnly = false;
              }
          }
      }