private String authorize() {
    try {
      OkHttpClient.Builder builder = client.newBuilder();
      builder.interceptors().remove(this);
      OkHttpClient clone = builder.build();

      String credential = Credentials.basic(config.getUsername(), new String(config.getPassword()));
      URL url = new URL(URLUtils.join(config.getMasterUrl(), AUTHORIZE_PATH));
      Response response =
          clone
              .newCall(
                  new Request.Builder().get().url(url).header(AUTHORIZATION, credential).build())
              .execute();

      response.body().close();
      response = response.priorResponse() != null ? response.priorResponse() : response;
      response = response.networkResponse() != null ? response.networkResponse() : response;
      String token = response.header(LOCATION);
      if (token == null || token.isEmpty()) {
        throw new KubernetesClientException(
            "Unexpected response ("
                + response.code()
                + " "
                + response.message()
                + "), to the authorization request. Missing header:["
                + LOCATION
                + "]!");
      }
      token = token.substring(token.indexOf(BEFORE_TOKEN) + BEFORE_TOKEN.length());
      token = token.substring(0, token.indexOf(AFTER_TOKEN));
      return token;
    } catch (Exception e) {
      throw KubernetesClientException.launderThrowable(e);
    }
  }
  @Override
  public DoneableReplicationController edit() {
    if (!rolling) {
      return super.edit();
    }

    final Visitor<ReplicationController> visitor =
        new Visitor<ReplicationController>() {
          @Override
          public void visit(ReplicationController rc) {
            try {
              new RollingUpdater(client, config, namespace).rollUpdate(getMandatory(), rc);
            } catch (Exception e) {
              throw KubernetesClientException.launderThrowable(e);
            }
          }
        };

    try {
      return getDoneableType()
          .getDeclaredConstructor(getType(), Visitor.class)
          .newInstance(get(), visitor);
    } catch (InvocationTargetException
        | NoSuchMethodException
        | IllegalAccessException
        | InstantiationException e) {
      throw KubernetesClientException.launderThrowable(e);
    }
  }
 public URL getRootUrl() {
   try {
     return new URL(
         URLUtils.join(config.getMasterUrl().toString(), "api", config.getApiVersion()));
   } catch (MalformedURLException e) {
     throw KubernetesClientException.launderThrowable(e);
   }
 }
 @Override
 public EditReplaceDeletable<T, T, D, Boolean> cascading(boolean enabled) {
   try {
     return getClass()
         .getConstructor(Client.class, String.class, String.class, Boolean.class, type)
         .newInstance(client, namespace, name, enabled, item);
   } catch (Throwable t) {
     throw KubernetesClientException.launderThrowable(t);
   }
 }
 @Override
 public ClientNonNamespaceOperation<C, T, L, D, R> inNamespace(String namespace) {
   try {
     return getClass()
         .getConstructor(Client.class, String.class, String.class, Boolean.class, type)
         .newInstance(client, namespace, name, cascading, item);
   } catch (Throwable t) {
     throw KubernetesClientException.launderThrowable(t);
   }
 }
 void deleteThis() throws KubernetesClientException {
   try {
     if (item != null) {
       handleDelete(item);
     } else {
       handleDelete(getResourceUrl());
     }
   } catch (Exception e) {
     throw KubernetesClientException.launderThrowable(e);
   }
 }
 @Override
 public R load(InputStream is) {
   try {
     return (R)
         getClass()
             .getConstructor(Client.class, String.class, String.class, Boolean.class, type)
             .newInstance(client, namespace, name, cascading, client.unmarshal(is, type));
   } catch (Throwable t) {
     throw KubernetesClientException.launderThrowable(t);
   }
 }
 public Watch watch(String resourceVersion, final Watcher<T> watcher)
     throws KubernetesClientException {
   try {
     return new WatchConnectionManager<>(
         this,
         resourceVersion,
         watcher,
         client.getConfiguration().getWatchReconnectInterval(),
         client.getConfiguration().getWatchReconnectLimit());
   } catch (MalformedURLException | InterruptedException | ExecutionException e) {
     throw KubernetesClientException.launderThrowable(e);
   }
 }
 @Override
 public Boolean delete(List<T> items) {
   try {
     for (T item : items) {
       handleDelete(item);
     }
   } catch (KubernetesClientException e) {
     if (e.getCode() != 404) {
       throw e;
     }
     return false;
   } catch (InterruptedException | ExecutionException | IOException e) {
     throw KubernetesClientException.launderThrowable(e);
   }
   return true;
 }
 @Override
 public T create(T... resources) throws KubernetesClientException {
   try {
     if (resources.length > 1) {
       throw new IllegalArgumentException("Too many items to create.");
     } else if (resources.length == 1) {
       return handleCreate(resources[0]);
     } else if (getItem() == null) {
       throw new IllegalArgumentException("Nothing to create.");
     } else {
       return handleCreate(getItem());
     }
   } catch (InterruptedException | ExecutionException | IOException e) {
     throw KubernetesClientException.launderThrowable(e);
   }
 }
 public RootPaths getRootPaths() {
   try {
     URL requestUrl = client.getMasterUrl();
     Future<Response> f = getClient().getHttpClient().prepareGet(requestUrl.toString()).execute();
     Response r = f.get();
     assertResponseCode(r, 200);
     return OBJECT_MAPPER.readValue(r.getResponseBodyAsStream(), RootPaths.class);
   } catch (KubernetesClientException e) {
     if (e.getCode() != 404) {
       throw e;
     }
     return null;
   } catch (InterruptedException | ExecutionException | IOException e) {
     throw KubernetesClientException.launderThrowable(e);
   }
 }
  protected <T> T unmarshal(InputStream is, Class<T> type) throws KubernetesClientException {
    try (BufferedInputStream bis = new BufferedInputStream(is)) {
      bis.mark(-1);
      int intch;
      do {
        intch = bis.read();
      } while (intch > -1 && Character.isWhitespace(intch));
      bis.reset();

      ObjectMapper mapper = JSON_MAPPER;
      if (intch != '{') {
        mapper = YAML_MAPPER;
      }
      return mapper.readValue(bis, type);
    } catch (IOException e) {
      throw KubernetesClientException.launderThrowable(e);
    }
  }
 @Override
 public T get() {
   if (item != null) {
     return item;
   }
   try {
     URL requestUrl = getNamespacedUrl();
     if (name != null) {
       requestUrl = new URL(URLUtils.join(requestUrl.toString(), name));
     }
     return handleGet(requestUrl);
   } catch (KubernetesClientException e) {
     if (e.getCode() != 404) {
       throw e;
     }
     return null;
   } catch (InterruptedException | ExecutionException | IOException e) {
     throw KubernetesClientException.launderThrowable(e);
   }
 }
 @Override
 public ClientRollableScallableResource<ReplicationController, DoneableReplicationController> load(
     InputStream is) {
   try {
     ReplicationController item = unmarshal(is, ReplicationController.class);
     return new ReplicationControllerOperationsImpl(
         client,
         getConfig(),
         getAPIVersion(),
         getNamespace(),
         getName(),
         isCascading(),
         item,
         getResourceVersion(),
         getReloadingFromServer(),
         rolling,
         rollingTimeout,
         rollingTimeUnit);
   } catch (Throwable t) {
     throw KubernetesClientException.launderThrowable(t);
   }
 }
  @Override
  public D createNew() throws KubernetesClientException {
    final Visitor<T> visitor =
        new Visitor<T>() {
          @Override
          public void visit(T resource) {
            try {
              create(resource);
            } catch (Exception e) {
              throw KubernetesClientException.launderThrowable(e);
            }
          }
        };

    try {
      return getDoneableType().getDeclaredConstructor(Visitor.class).newInstance(visitor);
    } catch (InvocationTargetException
        | NoSuchMethodException
        | IllegalAccessException
        | InstantiationException e) {
      throw KubernetesClientException.launderThrowable(e);
    }
  }
  public L list() throws KubernetesClientException {
    try {
      URL requestUrl = getNamespacedUrl();
      AsyncHttpClient.BoundRequestBuilder requestBuilder =
          getClient().getHttpClient().prepareGet(requestUrl.toString());

      String labelQueryParam = getLabelQueryParam();
      if (labelQueryParam.length() > 0) {
        requestBuilder.addQueryParam("labelSelector", labelQueryParam);
      }

      String fieldQueryString = getFieldQueryParam();
      if (fieldQueryString.length() > 0) {
        requestBuilder.addQueryParam("fieldSelector", fieldQueryString);
      }

      Future<Response> f = requestBuilder.execute();
      Response r = f.get();
      assertResponseCode(r, 200);
      return OBJECT_MAPPER.readValue(r.getResponseBodyAsStream(), listType);
    } catch (InterruptedException | ExecutionException | IOException e) {
      throw KubernetesClientException.launderThrowable(e);
    }
  }