org.eclipse.scout.rt.rest.jersey.client/src/main/java/org/eclipse/scout/rt/rest/jersey/client/connector_old/ScoutApacheConnector.java

///*
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
// *
// * Copyright (c) 2010-2015 Oracle and/or its affiliates. All rights reserved.
// *
// * The contents of this file are subject to the terms of either the GNU
// * General Public License Version 2 only ("GPL") or the Common Development
// * and Distribution License("CDDL") (collectively, the "License").  You
// * may not use this file except in compliance with the License.  You can
// * obtain a copy of the License at
// * http://glassfish.java.net/public/CDDL+GPL_1_1.html
// * or packager/legal/LICENSE.txt.  See the License for the specific
// * language governing permissions and limitations under the License.
// *
// * When distributing the software, include this License Header Notice in each
// * file and include the License file at packager/legal/LICENSE.txt.
// *
// * GPL Classpath Exception:
// * Oracle designates this particular file as subject to the "Classpath"
// * exception as provided by Oracle in the GPL Version 2 section of the License
// * file that accompanied this code.
// *
// * Modifications:
// * If applicable, add the following below the License Header, with the fields
// * enclosed by brackets [] replaced by your own identifying information:
// * "Portions Copyright [year] [name of copyright owner]"
// *
// * Contributor(s):
// * If you wish your version of this file to be governed by only the CDDL or
// * only the GPL Version 2, indicate your decision by adding "[Contributor]
// * elects to include this software in this distribution under the [CDDL or GPL
// * Version 2] license."  If you don't indicate a single choice of license, a
// * recipient has the option to distribute your version of this file under
// * either the CDDL, the GPL Version 2 or to extend the choice of license to
// * its licensees as provided above.  However, if you add GPL Version 2 code
// * and therefore, elected the GPL Version 2 license, then the option applies
// * only if the new code is made subject to such option by the copyright
// * holder.
// */
//package org.eclipse.scout.rt.rest.jersey.client.connector_old;
//
//import java.io.BufferedInputStream;
//import java.io.ByteArrayInputStream;
//import java.io.ByteArrayOutputStream;
//import java.io.FilterInputStream;
//import java.io.IOException;
//import java.io.InputStream;
//import java.io.OutputStream;
//import java.net.URI;
//import java.util.ArrayList;
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.Future;
//
//import javax.net.ssl.SSLContext;
//import javax.ws.rs.ProcessingException;
//import javax.ws.rs.client.Client;
//import javax.ws.rs.core.Configuration;
//import javax.ws.rs.core.HttpHeaders;
//import javax.ws.rs.core.MultivaluedMap;
//import javax.ws.rs.core.Response;
//
//import org.apache.http.Header;
//import org.apache.http.HttpEntity;
//import org.apache.http.HttpHost;
//import org.apache.http.auth.AuthScope;
//import org.apache.http.auth.UsernamePasswordCredentials;
//import org.apache.http.client.AuthCache;
//import org.apache.http.client.CookieStore;
//import org.apache.http.client.CredentialsProvider;
//import org.apache.http.client.config.CookieSpecs;
//import org.apache.http.client.config.RequestConfig;
//import org.apache.http.client.methods.CloseableHttpResponse;
//import org.apache.http.client.methods.HttpUriRequest;
//import org.apache.http.client.methods.RequestBuilder;
//import org.apache.http.client.protocol.HttpClientContext;
//import org.apache.http.conn.HttpClientConnectionManager;
//import org.apache.http.entity.AbstractHttpEntity;
//import org.apache.http.entity.BufferedHttpEntity;
//import org.apache.http.impl.auth.BasicScheme;
//import org.apache.http.impl.client.BasicAuthCache;
//import org.apache.http.impl.client.BasicCookieStore;
//import org.apache.http.impl.client.BasicCredentialsProvider;
//import org.apache.http.impl.client.CloseableHttpClient;
//import org.apache.http.impl.client.HttpClientBuilder;
//import org.eclipse.scout.rt.platform.config.CONFIG;
//import org.eclipse.scout.rt.platform.config.PlatformConfigProperties.ApplicationVersionProperty;
//import org.eclipse.scout.rt.platform.context.RunMonitor;
//import org.eclipse.scout.rt.platform.util.Assertions;
//import org.eclipse.scout.rt.platform.util.concurrent.ICancellable;
//import org.glassfish.jersey.client.ClientProperties;
//import org.glassfish.jersey.client.ClientRequest;
//import org.glassfish.jersey.client.ClientResponse;
//import org.glassfish.jersey.client.RequestEntityProcessing;
//import org.glassfish.jersey.client.spi.AsyncConnectorCallback;
//import org.glassfish.jersey.client.spi.Connector;
//import org.glassfish.jersey.internal.util.PropertiesHelper;
//import org.glassfish.jersey.message.internal.HeaderUtils;
//import org.glassfish.jersey.message.internal.OutboundMessageContext;
//import org.glassfish.jersey.message.internal.ReaderWriter;
//import org.glassfish.jersey.message.internal.Statuses;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
//import jersey.repackaged.com.google.common.util.concurrent.MoreExecutors;
//
/////**
//// * A {@link Connector} that utilizes the Apache HTTP Client to send and receive HTTP request and responses.
//// * <p/>
//// * The following properties are only supported at construction of this class:
//// * <ul>
//// * <li>{@link ApacheClientProperties#CONNECTION_MANAGER}</li>
//// * <li>{@link ApacheClientProperties#REQUEST_CONFIG}</li>
//// * <li>{@link ApacheClientProperties#CREDENTIALS_PROVIDER}</li>
//// * <li>{@link ApacheClientProperties#DISABLE_COOKIES}</li>
//// * <li>{@link ClientProperties#PROXY_URI}</li>
//// * <li>{@link ClientProperties#PROXY_USERNAME}</li>
//// * <li>{@link ClientProperties#PROXY_PASSWORD}</li>
//// * <li>{@link ClientProperties#REQUEST_ENTITY_PROCESSING} - default value is
//// * {@link RequestEntityProcessing#CHUNKED}</li>
//// * <li>{@link ApacheClientProperties#PREEMPTIVE_BASIC_AUTHENTICATION}</li>
//// * </ul>
//// * <p>
//// * This connector uses {@link RequestEntityProcessing#CHUNKED chunked encoding} as a default setting. This can be
//// * overridden by the {@link ClientProperties#REQUEST_ENTITY_PROCESSING}. By default the
//// * {@link ClientProperties#CHUNKED_ENCODING_SIZE} property is only supported by using default connection manager. If
//// * custom connection manager needs to be used then chunked encoding size can be set by providing a custom
//// * {@link org.apache.http.HttpClientConnection} (via custom
//// * {@link org.apache.http.impl.conn.ManagedHttpClientConnectionFactory}) and overriding {@code createOutputStream}
//// * method.
//// * </p>
//// * <p>
//// * Using of authorization is dependent on the chunk encoding setting. If the entity buffering is enabled, the entity is
//// * buffered and authorization can be performed automatically in response to a 401 by sending the request again. When
//// * entity buffering is disabled (chunked encoding is used) then the property
//// * {@link org.glassfish.jersey.apache.connector.ApacheClientProperties#PREEMPTIVE_BASIC_AUTHENTICATION} must be set to
//// * {@code true}.
//// * </p>
//// * <p>
//// * If a {@link org.glassfish.jersey.client.ClientResponse} is obtained and an entity is not read from the response then
//// * {@link org.glassfish.jersey.client.ClientResponse#close()} MUST be called after processing the response to release
//// * connection-based resources.
//// * </p>
//// * <p>
//// * Client operations are thread safe, the HTTP connection may be shared between different threads.
//// * </p>
//// * <p>
//// * If a response entity is obtained that is an instance of {@link Closeable} then the instance MUST be closed after
//// * processing the entity to release connection-based resources.
//// * </p>
//// * <p>
//// * The following methods are currently supported: HEAD, GET, POST, PUT, DELETE, OPTIONS, PATCH and TRACE.
//// * </p>
//// *
//// * @author jorgeluisw@mac.com
//// * @author Paul Sandoz
//// * @author Pavel Bucek (pavel.bucek at oracle.com)
//// * @author Arul Dhesiaseelan (aruld at acm.org)
//// * @see ApacheClientProperties#CONNECTION_MANAGER
//// */
////@SuppressWarnings("deprecation")
//public class ScoutApacheConnector implements Connector {
//
////  private static final Logger LOGGER = Logger.getLogger(ScoutApacheConnector.class.getName());
//
//  private static final Logger LOG = LoggerFactory.getLogger(ScoutApacheConnector.class);
//
////  private static final VersionInfo vi;
////  private static final String release;
//
////  static {
////    vi = VersionInfo.loadVersionInfo("org.apache.http.client", HttpClientBuilder.class.getClassLoader());
////    release = (vi != null) ? vi.getRelease() : VersionInfo.UNAVAILABLE;
////  }
//
//  private final CloseableHttpClient m_client;
//  private final CookieStore m_cookieStore;
//  private final boolean m_preemptiveBasicAuth;
//  private final RequestConfig m_requestConfig;
//
//  /**
//   * Create the new Apache HTTP Client connector.
//   *
//   * @param client
//   *          JAX-RS client instance for which the connector is being created.
//   * @param config
//   *          client configuration.
//   */
//  ScoutApacheConnector(final Client client, final Configuration config) {
////    final Object connectionManager = config.getProperties().get(ApacheClientProperties.CONNECTION_MANAGER);
////    if (connectionManager != null) {
////      if (!(connectionManager instanceof HttpClientConnectionManager)) {
////        LOGGER.log(
////            Level.WARNING,
////            LocalizationMessages.IGNORING_VALUE_OF_PROPERTY(
////                ApacheClientProperties.CONNECTION_MANAGER,
////                connectionManager.getClass().getName(),
////                HttpClientConnectionManager.class.getName()));
////      }
////    }
//
//    Object reqConfig = config.getProperties().get(ApacheClientProperties.REQUEST_CONFIG);
//    if (reqConfig != null) {
//      if (!(reqConfig instanceof RequestConfig)) {
//        LOG.warn("ignoring value of property");
//
////        LOGGER.log(
////            Level.WARNING,
////            LocalizationMessages.IGNORING_VALUE_OF_PROPERTY(
////                ApacheClientProperties.REQUEST_CONFIG,
////                reqConfig.getClass().getName(),
////                RequestConfig.class.getName()));
//        reqConfig = null;
//      }
//    }
//
//    final SSLContext sslContext = client.getSslContext();
//    final HttpClientBuilder clientBuilder = HttpClientBuilder.create();
//
//    clientBuilder.setConnectionManager(getConnectionManager(client, config, sslContext));
//    clientBuilder.setConnectionManagerShared(
//        PropertiesHelper.getValue(config.getProperties(), ApacheClientProperties.CONNECTION_MANAGER_SHARED, false, null));
//    clientBuilder.setSSLContext(sslContext);
//
//    final RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
//
//    final Object credentialsProvider = config.getProperty(ApacheClientProperties.CREDENTIALS_PROVIDER);
//    if (credentialsProvider != null && (credentialsProvider instanceof CredentialsProvider)) {
//      clientBuilder.setDefaultCredentialsProvider((CredentialsProvider) credentialsProvider);
//    }
//
//    final Object proxyUri;
//    proxyUri = config.getProperty(ClientProperties.PROXY_URI);
//    if (proxyUri != null) {
//      final URI u = getProxyUri(proxyUri);
//      final HttpHost proxy = new HttpHost(u.getHost(), u.getPort(), u.getScheme());
//      final String userName;
//      userName = ClientProperties.getValue(config.getProperties(), ClientProperties.PROXY_USERNAME, String.class);
//      if (userName != null) {
//        final String password;
//        password = ClientProperties.getValue(config.getProperties(), ClientProperties.PROXY_PASSWORD, String.class);
//
//        if (password != null) {
//          final CredentialsProvider credsProvider = new BasicCredentialsProvider();
//          credsProvider.setCredentials(
//              new AuthScope(u.getHost(), u.getPort()),
//              new UsernamePasswordCredentials(userName, password));
//          clientBuilder.setDefaultCredentialsProvider(credsProvider);
//        }
//      }
//      clientBuilder.setProxy(proxy);
//    }
//
//    final Boolean preemptiveBasicAuthProperty = (Boolean) config.getProperties()
//        .get(ApacheClientProperties.PREEMPTIVE_BASIC_AUTHENTICATION);
//    this.m_preemptiveBasicAuth = (preemptiveBasicAuthProperty != null) ? preemptiveBasicAuthProperty : false;
//
//    final boolean ignoreCookies = PropertiesHelper.isProperty(config.getProperties(), ApacheClientProperties.DISABLE_COOKIES);
//
//    if (reqConfig != null) {
//      final RequestConfig.Builder reqConfigBuilder = RequestConfig.copy((RequestConfig) reqConfig);
//      if (ignoreCookies) {
//        reqConfigBuilder.setCookieSpec(CookieSpecs.IGNORE_COOKIES);
//      }
//      m_requestConfig = reqConfigBuilder.build();
//    }
//    else {
//      if (ignoreCookies) {
//        requestConfigBuilder.setCookieSpec(CookieSpecs.IGNORE_COOKIES);
//      }
//      m_requestConfig = requestConfigBuilder.build();
//    }
//
//    if (m_requestConfig.getCookieSpec() == null || !m_requestConfig.getCookieSpec().equals(CookieSpecs.IGNORE_COOKIES)) {
//      this.m_cookieStore = new BasicCookieStore();
//      clientBuilder.setDefaultCookieStore(m_cookieStore);
//    }
//    else {
//      this.m_cookieStore = null;
//    }
//    clientBuilder.setDefaultRequestConfig(m_requestConfig);
//    this.m_client = clientBuilder.build();
//  }
//
//  private HttpClientConnectionManager getConnectionManager(final Client client,
//      final Configuration config,
//      final SSLContext sslContext) {
//    final Object cmObject = config.getProperties().get(ApacheClientProperties.CONNECTION_MANAGER);
//
//    return Assertions.assertType(cmObject, HttpClientConnectionManager.class);
//
//    // Connection manager from configuration.
////    if (cmObject != null) {
////      if (cmObject instanceof HttpClientConnectionManager) {
////        return (HttpClientConnectionManager) cmObject;
////      }
////      else {
////        LOGGER.log(
////            Level.WARNING,
////            LocalizationMessages.IGNORING_VALUE_OF_PROPERTY(
////                ApacheClientProperties.CONNECTION_MANAGER,
////                cmObject.getClass().getName(),
////                HttpClientConnectionManager.class.getName()));
////      }
////    }
//
//    // Create custom connection manager.
////    return createConnectionManager(
////        client,
////        config,
////        sslContext,
////        false);
//  }
//
////  private HttpClientConnectionManager createConnectionManager(
////      final Client client,
////      final Configuration config,
////      final SSLContext sslContext,
////      final boolean useSystemProperties) {
////
////    final String[] supportedProtocols = useSystemProperties ? split(
////        System.getProperty("https.protocols")) : null;
////    final String[] supportedCipherSuites = useSystemProperties ? split(
////        System.getProperty("https.cipherSuites")) : null;
////
////    HostnameVerifier hostnameVerifier = client.getHostnameVerifier();
////
////    final LayeredConnectionSocketFactory sslSocketFactory;
////    if (sslContext != null) {
////      sslSocketFactory = new SSLConnectionSocketFactory(
////          sslContext, supportedProtocols, supportedCipherSuites, hostnameVerifier);
////    }
////    else {
////      if (useSystemProperties) {
////        sslSocketFactory = new SSLConnectionSocketFactory(
////            (SSLSocketFactory) SSLSocketFactory.getDefault(),
////            supportedProtocols, supportedCipherSuites, hostnameVerifier);
////      }
////      else {
////        sslSocketFactory = new SSLConnectionSocketFactory(
////            SSLContexts.createDefault(),
////            hostnameVerifier);
////      }
////    }
////
////    final Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create()
////        .register("http", PlainConnectionSocketFactory.getSocketFactory())
////        .register("https", sslSocketFactory)
////        .build();
////
////    final Integer chunkSize = ClientProperties.getValue(config.getProperties(),
////        ClientProperties.CHUNKED_ENCODING_SIZE, ClientProperties.DEFAULT_CHUNK_SIZE, Integer.class);
////
////    final PoolingHttpClientConnectionManager connectionManager =
////        new PoolingHttpClientConnectionManager(registry, new ConnectionFactory(chunkSize));
////
////    if (useSystemProperties) {
////      String s = System.getProperty("http.keepAlive", "true");
////      if ("true".equalsIgnoreCase(s)) {
////        s = System.getProperty("http.maxConnections", "5");
////        final int max = Integer.parseInt(s);
////        connectionManager.setDefaultMaxPerRoute(max);
////        connectionManager.setMaxTotal(2 * max);
////      }
////    }
////
////    return connectionManager;
////  }
//
////  private static String[] split(final String s) {
////    if (TextUtils.isBlank(s)) {
////      return null;
////    }
////    return s.split(" *, *");
////  }
//
////  /**
////   * Get the {@link HttpClient}.
////   *
////   * @return the {@link HttpClient}.
////   */
////  @SuppressWarnings("UnusedDeclaration")
////  public HttpClient getHttpClient() {
////    return client;
////  }
//
////  /**
////   * Get the {@link CookieStore}.
////   *
////   * @return the {@link CookieStore} instance or {@code null} when {@value ApacheClientProperties#DISABLE_COOKIES} set
////   *         to {@code true}.
////   */
////  public CookieStore getCookieStore() {
////    return cookieStore;
////  }
//
//  private static URI getProxyUri(final Object proxy) {
//    if (proxy instanceof URI) {
//      return (URI) proxy;
//    }
//    else if (proxy instanceof String) {
//      return URI.create((String) proxy);
//    }
//    else {
//      throw new ProcessingException("WRONG_PROXY_URI_TYPE" /*LocalizationMessages.WRONG_PROXY_URI_TYPE(ClientProperties.PROXY_URI)*/);
//    }
//  }
//
//  @Override
//  public ClientResponse apply(final ClientRequest clientRequest) {
//    final HttpUriRequest request = getUriHttpRequest(clientRequest);
//    final Map<String, String> clientHeadersSnapshot = writeOutBoundHeaders(clientRequest.getHeaders(), request);
//
//    registerCancellable(request);
//
//    try {
//      final CloseableHttpResponse response;
//      final HttpClientContext context = HttpClientContext.create();
//      if (m_preemptiveBasicAuth) {
//        final AuthCache authCache = new BasicAuthCache();
//        final BasicScheme basicScheme = new BasicScheme();
//        authCache.put(getHost(request), basicScheme);
//        context.setAuthCache(authCache);
//      }
//      response = m_client.execute(getHost(request), request, context);
//      HeaderUtils.checkHeaderChanges(clientHeadersSnapshot, clientRequest.getHeaders(), this.getClass().getName());
//
//      final Response.StatusType status = response.getStatusLine().getReasonPhrase() == null
//          ? Statuses.from(response.getStatusLine().getStatusCode())
//          : Statuses.from(response.getStatusLine().getStatusCode(), response.getStatusLine().getReasonPhrase());
//
//      final ClientResponse responseContext = new ClientResponse(status, clientRequest);
//      final List<URI> redirectLocations = context.getRedirectLocations();
//      if (redirectLocations != null && !redirectLocations.isEmpty()) {
//        responseContext.setResolvedRequestUri(redirectLocations.get(redirectLocations.size() - 1));
//      }
//
//      final Header[] respHeaders = response.getAllHeaders();
//      final MultivaluedMap<String, String> headers = responseContext.getHeaders();
//      for (final Header header : respHeaders) {
//        final String headerName = header.getName();
//        List<String> list = headers.get(headerName);
//        if (list == null) {
//          list = new ArrayList<>();
//        }
//        list.add(header.getValue());
//        headers.put(headerName, list);
//      }
//
//      final HttpEntity entity = response.getEntity();
//
//      if (entity != null) {
//        if (headers.get(HttpHeaders.CONTENT_LENGTH) == null) {
//          headers.add(HttpHeaders.CONTENT_LENGTH, String.valueOf(entity.getContentLength()));
//        }
//
//        final Header contentEncoding = entity.getContentEncoding();
//        if (headers.get(HttpHeaders.CONTENT_ENCODING) == null && contentEncoding != null) {
//          headers.add(HttpHeaders.CONTENT_ENCODING, contentEncoding.getValue());
//        }
//      }
//
//      try {
//        responseContext.setEntityStream(new HttpClientResponseInputStream(getInputStream(response)));
//      }
//      catch (final IOException e) {
////        LOGGER.log(Level.SEVERE, null, e);
//        LOG.error("apply failed", e);
//      }
//
//      return responseContext;
//    }
//    catch (final Exception e) {
//      throw new ProcessingException(e);
//    }
//  }
//
//  /**
//   * Registers an {@link ICancellable} if this method is invoked in the context of a {@link RunMonitor} (i.e.
//   * {@link RunMonitor#CURRENT} is not {@code null}).
//   */
//  protected void registerCancellable(final HttpUriRequest request) {
//    RunMonitor runMonitor = RunMonitor.CURRENT.get();
//    if (runMonitor != null) {
//      runMonitor.registerCancellable(new ICancellable() {
//
//        @Override
//        public boolean isCancelled() {
//          return request.isAborted();
//        }
//
//        @Override
//        public boolean cancel(boolean interruptIfRunning) {
////          LOGGER.fine("Aborting HTTP REST request");
//          LOG.debug("Aborting HTTP REST request");
//          request.abort();
//          return true;
//        }
//      });
//    }
//  }
//
//  @Override
//  public Future<?> apply(final ClientRequest request, final AsyncConnectorCallback callback) {
//    return MoreExecutors.sameThreadExecutor().submit(new Runnable() {
//      @Override
//      public void run() {
//        try {
//          callback.response(apply(request));
//        }
//        catch (final Throwable t) {
//          callback.failure(t);
//        }
//      }
//    });
//  }
//
//  @Override
//  public String getName() {
//    return "Apache HttpClient " + CONFIG.getPropertyValue(ApplicationVersionProperty.class); //release;
//  }
//
//  @Override
//  public void close() {
//    try {
//      m_client.close();
//    }
//    catch (final IOException e) {
//      throw new ProcessingException("FAILED_TO_STOP_CLIENT" /*LocalizationMessages.FAILED_TO_STOP_CLIENT()*/, e);
//    }
//  }
//
//  private HttpHost getHost(final HttpUriRequest request) {
//    return new HttpHost(request.getURI().getHost(), request.getURI().getPort(), request.getURI().getScheme());
//  }
//
//  private HttpUriRequest getUriHttpRequest(final ClientRequest clientRequest) {
//    final RequestConfig.Builder requestConfigBuilder = RequestConfig.copy(m_requestConfig);
//
//    final int connectTimeout = clientRequest.resolveProperty(ClientProperties.CONNECT_TIMEOUT, -1);
//    final int socketTimeout = clientRequest.resolveProperty(ClientProperties.READ_TIMEOUT, -1);
//
//    if (connectTimeout >= 0) {
//      requestConfigBuilder.setConnectTimeout(connectTimeout);
//    }
//    if (socketTimeout >= 0) {
//      requestConfigBuilder.setSocketTimeout(socketTimeout);
//    }
//
//    final Boolean redirectsEnabled =
//        clientRequest.resolveProperty(ClientProperties.FOLLOW_REDIRECTS, m_requestConfig.isRedirectsEnabled());
//    requestConfigBuilder.setRedirectsEnabled(redirectsEnabled);
//
//    final Boolean bufferingEnabled = clientRequest.resolveProperty(ClientProperties.REQUEST_ENTITY_PROCESSING,
//        RequestEntityProcessing.class) == RequestEntityProcessing.BUFFERED;
//    final HttpEntity entity = getHttpEntity(clientRequest, bufferingEnabled);
//
//    return RequestBuilder
//        .create(clientRequest.getMethod())
//        .setUri(clientRequest.getUri())
//        .setConfig(requestConfigBuilder.build())
//        .setEntity(entity)
//        .build();
//  }
//
//  private HttpEntity getHttpEntity(final ClientRequest clientRequest, final boolean bufferingEnabled) {
//    final Object entity = clientRequest.getEntity();
//
//    if (entity == null) {
//      return null;
//    }
//
//    final AbstractHttpEntity httpEntity = new AbstractHttpEntity() {
//      @Override
//      public boolean isRepeatable() {
//        return false;
//      }
//
//      @Override
//      public long getContentLength() {
//        return -1;
//      }
//
//      @Override
//      public InputStream getContent() throws IOException, IllegalStateException {
//        if (bufferingEnabled) {
//          final ByteArrayOutputStream buffer = new ByteArrayOutputStream(512);
//          writeTo(buffer);
//          return new ByteArrayInputStream(buffer.toByteArray());
//        }
//        else {
//          return null;
//        }
//      }
//
//      @Override
//      public void writeTo(final OutputStream outputStream) throws IOException {
//        clientRequest.setStreamProvider(new OutboundMessageContext.StreamProvider() {
//          @Override
//          public OutputStream getOutputStream(final int contentLength) throws IOException {
//            return outputStream;
//          }
//        });
//        clientRequest.writeEntity();
//      }
//
//      @Override
//      public boolean isStreaming() {
//        return false;
//      }
//    };
//
//    if (bufferingEnabled) {
//      try {
//        return new BufferedHttpEntity(httpEntity);
//      }
//      catch (final IOException e) {
//        throw new ProcessingException("ERROR_BUFFERING_ENTITY" /*LocalizationMessages.ERROR_BUFFERING_ENTITY()*/, e);
//      }
//    }
//    else {
//      return httpEntity;
//    }
//  }
//
//  private static Map<String, String> writeOutBoundHeaders(final MultivaluedMap<String, Object> headers,
//      final HttpUriRequest request) {
//    final Map<String, String> stringHeaders = HeaderUtils.asStringHeadersSingleValue(headers);
//
//    for (final Map.Entry<String, String> e : stringHeaders.entrySet()) {
//      request.addHeader(e.getKey(), e.getValue());
//    }
//    return stringHeaders;
//  }
//
//  private static final class HttpClientResponseInputStream extends FilterInputStream {
//
//    HttpClientResponseInputStream(final InputStream inputStream) throws IOException {
//      super(inputStream);
//    }
//
//    @Override
//    public void close() throws IOException {
//      super.close();
//    }
//  }
//
//  private static InputStream getInputStream(final CloseableHttpResponse response) throws IOException {
//
//    final InputStream inputStream;
//
//    if (response.getEntity() == null) {
//      inputStream = new ByteArrayInputStream(new byte[0]);
//    }
//    else {
//      final InputStream i = response.getEntity().getContent();
//      if (i.markSupported()) {
//        inputStream = i;
//      }
//      else {
//        inputStream = new BufferedInputStream(i, ReaderWriter.BUFFER_SIZE);
//      }
//    }
//
//    return new FilterInputStream(inputStream) {
//      @Override
//      public void close() throws IOException {
//        try {
//          super.close();
//        }
//        catch (@SuppressWarnings("squid:S1166") IOException ex) {
//          // Ignore
//        }
//        finally {
//          response.close();
//        }
//      }
//    };
//
////    return new FilterInputStream(inputStream) {
////      @Override
////      public void close() throws IOException {
////        response.close();
////        super.close();
////      }
////    };
//  }
//
////  private static class ConnectionFactory extends ManagedHttpClientConnectionFactory {
////
////    private static final AtomicLong COUNTER = new AtomicLong();
////
////    private final int chunkSize;
////
////    private ConnectionFactory(final int chunkSize) {
////      this.chunkSize = chunkSize;
////    }
////
////    @Override
////    public ManagedHttpClientConnection create(final HttpRoute route, final ConnectionConfig config) {
////      final String id = "http-outgoing-" + Long.toString(COUNTER.getAndIncrement());
////
////      return new HttpClientConnection(id, config.getBufferSize(), chunkSize);
////    }
////  }
//
////  private static class HttpClientConnection extends DefaultManagedHttpClientConnection {
////
////    private final int chunkSize;
////
////    private HttpClientConnection(final String id, final int buffersize, final int chunkSize) {
////      super(id, buffersize);
////
////      this.chunkSize = chunkSize;
////    }
////
////    @Override
////    protected OutputStream createOutputStream(final long len, final SessionOutputBuffer outbuffer) {
////      if (len == ContentLengthStrategy.CHUNKED) {
////        return new ChunkedOutputStream(chunkSize, outbuffer);
////      }
////      return super.createOutputStream(len, outbuffer);
////    }
////  }
//}