Java Examples for org.apache.http.impl.client.HttpClientBuilder

public HttpClientBuilder buildHttpClient() {
    final HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    final List<Header> headers = Lists.newArrayList(new BasicHeader("Accept", "*/*"), new BasicHeader("User-Agent", USER_AGENT));
    httpClientBuilder.setDefaultHeaders(headers);
    httpClientBuilder.setRedirectStrategy(new DefaultRedirectStrategy());
    return httpClientBuilder;
}

public static String getUrlContents(String url) {
    try {
        HttpClient client = HttpClientBuilder.create().build();
        HttpGet request = new HttpGet(url);
        HttpResponse response = client.execute(request);
        BufferedReader rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
        StringBuffer result = new StringBuffer();
        String line = "";
        while ((line = rd.readLine()) != null) {
            result.append(line);
        }
        return line;
    } catch (IOException io) {
    }
    return null;
}

/**
     * generator
     * <p>
     * 
     * @author chen.chen.9, 2013-8-19
     * @param timeout
     *            time out
     * @return {@link CloseableHttpClient}
     */
public static CloseableHttpClient generate(int timeout) {
    if (timeout <= 0) {
        timeout = DEFAULT_TIME_OUT;
    }
    RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(timeout).setSocketTimeout(timeout).setConnectTimeout(timeout).build();
    HttpClientBuilder httpClientBuilder = HttpClients.custom().setDefaultRequestConfig(requestConfig);
    return httpClientBuilder.build();
}

public static void main(String[] args) {
    try {
        HttpGet get = new HttpGet("http://10.1.0.11/cgi-bin/ConfigManApp.com?number=123-456-7890");
        CredentialsProvider provider = new BasicCredentialsProvider();
        UsernamePasswordCredentials credentials = new UsernamePasswordCredentials("admin", "admin");
        provider.setCredentials(AuthScope.ANY, credentials);
        HttpClient client = HttpClientBuilder.create().setDefaultCredentialsProvider(provider).build();
        HttpResponse response = client.execute(get);
        int statusCode = response.getStatusLine().getStatusCode();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Bean
@Scope("prototype")
@SuppressWarnings("deprecation")
public CloseableHttpClient build() {
    final RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(1000).setConnectTimeout(1000).setSocketTimeout(1000).build();
    try {
        return HttpClientBuilder.create().disableAuthCaching().disableAutomaticRetries().disableConnectionState().disableCookieManagement().disableRedirectHandling().setDefaultRequestConfig(config).setUserAgent("fullstop-job (https://github.com/zalando-stups/fullstop)").setHostnameVerifier(new AllowAllHostnameVerifier()).setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, ( arrayX509Certificate,  value) -> true).build()).build();
    } catch (NoSuchAlgorithmExceptionKeyManagementException | KeyStoreException |  e) {
        throw new IllegalStateException("Could not initialize httpClient", e);
    }
}

public static SlackApi getClient() {
    PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
    HttpClient httpClient = HttpClientBuilder.create().setConnectionManager(cm).build();
    //
    ClientExecutor executor = new ApacheHttpClient4Executor(httpClient);
    // new ApacheHttpClient4Engine(httpClient);
    //
    SlackApi slackApi = ProxyFactory.create(SlackApi.class, "https://hooks.slack.com", executor);
    // SlackApi slackApi = target.proxy(SlackApi.class);
    return slackApi;
}

public CloseableHttpClient build() {
    org.apache.http.impl.client.HttpClientBuilder internalHttpClientBuilder = createInternalHttpClientBuilder();
    boolean acceptAnyCertificate = false;
    boolean acceptAnyHostname = false;
    if (useSystemProperties) {
        internalHttpClientBuilder.useSystemProperties();
        if (WebProperties.WEB_HTTPS_ALLOW_ANY_CERTIFICATE.getValueAsBoolean()) {
            acceptAnyCertificate = true;
        }
        if (WebProperties.WEB_HTTPS_ALLOW_ANY_HOSTNAME.getValueAsBoolean()) {
            acceptAnyHostname = true;
        }
    }
    if (allowAnyHostname != null) {
        if (allowAnyHostname) {
            acceptAnyHostname = true;
        } else {
            acceptAnyHostname = false;
        }
    }
    if (allowAnyCertificate != null) {
        if (allowAnyCertificate) {
            acceptAnyCertificate = true;
        } else {
            acceptAnyCertificate = false;
        }
    }
    if (acceptAnyCertificate) {
        internalHttpClientBuilder.setSslcontext(createSslContext());
    }
    if (acceptAnyHostname) {
        internalHttpClientBuilder.setHostnameVerifier(SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    }
    if (maxConnections > 0) {
        internalHttpClientBuilder.setMaxConnPerRoute(maxConnections);
        internalHttpClientBuilder.setMaxConnTotal(maxConnections);
    }
    if (requestConfig != null) {
        internalHttpClientBuilder.setDefaultRequestConfig(requestConfig);
    }
    if (!useContentCompression) {
        internalHttpClientBuilder.disableContentCompression();
    }
    return internalHttpClientBuilder.build();
}

public CloseableHttpClient build() {
    org.apache.http.impl.client.HttpClientBuilder internalHttpClientBuilder = createInternalHttpClientBuilder();
    boolean acceptAnyCertificate = false;
    boolean acceptAnyHostname = false;
    if (useSystemProperties) {
        internalHttpClientBuilder.useSystemProperties();
        if (WebProperties.WEB_HTTPS_ALLOW_ANY_CERTIFICATE.getValueAsBoolean()) {
            acceptAnyCertificate = true;
        }
        if (WebProperties.WEB_HTTPS_ALLOW_ANY_HOSTNAME.getValueAsBoolean()) {
            acceptAnyHostname = true;
        }
    }
    if (allowAnyHostname != null) {
        if (allowAnyHostname) {
            acceptAnyHostname = true;
        } else {
            acceptAnyHostname = false;
        }
    }
    if (allowAnyCertificate != null) {
        if (allowAnyCertificate) {
            acceptAnyCertificate = true;
        } else {
            acceptAnyCertificate = false;
        }
    }
    if (acceptAnyCertificate) {
        internalHttpClientBuilder.setSslcontext(createSslContext());
    }
    if (acceptAnyHostname) {
        internalHttpClientBuilder.setHostnameVerifier(SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    }
    if (maxConnections > 0) {
        internalHttpClientBuilder.setMaxConnPerRoute(maxConnections);
        internalHttpClientBuilder.setMaxConnTotal(maxConnections);
    }
    if (requestConfig != null) {
        internalHttpClientBuilder.setDefaultRequestConfig(requestConfig);
    }
    if (!useContentCompression) {
        internalHttpClientBuilder.disableContentCompression();
    }
    return internalHttpClientBuilder.build();
}

/**
	 * To simplify client-side coding, the video should be immediately available for download if 
	 * available. At the time of writing, this work is not done synchronously with the session tear-down,
	 * which complicates video retrieval and storage.
	 * 
	 * @throws Exception
	 */
@Test
public void testVideoImmediatelyAvailable() throws Exception {
    DesiredCapabilities caps = DesiredCapabilities.firefox();
    RemoteWebDriver driver = new RemoteWebDriver(caps);
    System.out.println("Session: " + driver.getSessionId().toString());
    driver.get("http://www.google.com");
    SessionId sessionId = driver.getSessionId();
    driver.quit();
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet("http://127.0.0.1:4444/grid/admin/HubVideoDownloadServlet?sessionId=" + sessionId.toString());
    CloseableHttpResponse response = httpClient.execute(httpGet);
    Assert.assertEquals(200, response.getStatusLine().getStatusCode());
}

/**
	 * execute a http request and return answer or null if status code > 300
	 * 
	 * @param request
	 *            to execute including url & parameter
	 * @return response or null if error occured somewhere
	 * @throws IOException
	 */
public static String executeHttpRequest(HttpUriRequest request) throws IOException {
    HttpClient client = HttpClientBuilder.create().setMaxConnPerRoute(1337).build();
    try {
        HttpResponse response = client.execute(request);
        InputStream in = response.getEntity().getContent();
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        String line = null;
        StringBuffer bf = new StringBuffer();
        while ((line = reader.readLine()) != null) {
            bf.append(line);
        }
        return bf.toString();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    }
    return null;
}

public static void bypassSSL(HttpClientBuilder builder) {
    // Imports: javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager
    try {
        // Create a trust manager that does not validate certificate chains
        final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {

            @Override
            public void checkClientTrusted(final X509Certificate[] chain, final String authType) {
            }

            @Override
            public void checkServerTrusted(final X509Certificate[] chain, final String authType) {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        } };
        // Install the all-trusting trust manager
        final SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
        // Create an ssl socket factory with our all-trusting manager
        builder.setSslcontext(sslContext);
    } catch (final Exception e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) throws URISyntaxException, HttpException, IOException {
    CloseableHttpClient httpclient = HttpClientBuilder.create().build();
    HttpGet httpget = new HttpGet("http://www.google.com/");
    HttpResponse response = httpclient.execute(httpget);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        InputStream instream = entity.getContent();
        int l;
        byte[] tmp = new byte[2048];
        while ((l = instream.read(tmp)) != -1) {
            String s = new String(tmp);
            System.out.println(s);
        }
    }
    System.out.println("**************************");
    Header[] elements = response.getAllHeaders();
    for (Header header : elements) {
        System.out.println(header.getName() + " : " + header.getValue());
    }
    System.out.println();
    System.out.println("**************************");
    httpclient.close();
}

@Bean
public RestTemplate getRestTemplate() {
    // credential
    Credentials credentials = new UsernamePasswordCredentials(restUsername, restPassword);
    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, credentials);
    // accept header
    HttpRequestInterceptor acceptHeaderInterceptor = ( request,  context) -> request.addHeader("Accept", "application/xml");
    // build client
    HttpClient client = //
    HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider//
    ).addInterceptorFirst(acceptHeaderInterceptor).build();
    return new RestTemplate(new HttpComponentsClientHttpRequestFactory(client));
}

/**
     * 根��置自动生�需�的Cookies
     * @param httpClient
     * @param setting
     */
public void generateCookies(HttpClientBuilder httpClient, Setting setting) {
    CookieStore cookieStore = new BasicCookieStore();
    for (Map.Entry<String, String> cookieEntry : setting.getCookies().entrySet()) {
        BasicClientCookie cookie = new BasicClientCookie(cookieEntry.getKey(), cookieEntry.getValue());
        cookie.setDomain(setting.getDomain());
        cookie.setPath("/");
        cookieStore.addCookie(cookie);
        httpClient.setDefaultCookieStore(cookieStore).build();
    }
}

protected HttpClient getClient() {
    if (client == null) {
        URI uri = URI.create(url);
        BasicCredentialsProvider creds = new BasicCredentialsProvider();
        creds.setCredentials(new AuthScope(uri.getHost(), uri.getPort()), new UsernamePasswordCredentials(account.username, account.httpPassword));
        client = HttpClientBuilder.create().setDefaultCredentialsProvider(creds).setMaxConnPerRoute(10).setMaxConnTotal(1024).build();
    }
    return client;
}

public void afterPropertiesSet() throws UnsupportedEncodingException {
    Collection<Header> defaultHeaders = new ArrayList<Header>();
    Header header = new BasicHeader("Authorization", "Basic " + BaseEncoding.base64().encode("apollo:".getBytes("UTF-8")));
    defaultHeaders.add(header);
    BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("apollo", ""));
    CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider).setDefaultHeaders(defaultHeaders).build();
    restTemplate = new RestTemplate(httpMessageConverters.getConverters());
    HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
    requestFactory.setConnectTimeout(portalConfig.connectTimeout());
    requestFactory.setReadTimeout(portalConfig.readTimeout());
    restTemplate.setRequestFactory(requestFactory);
}

@Test
public void testRedirect() throws Exception {
    HttpGet get = new HttpGet("http://localhost:" + portNum + "/users/homer");
    // do not follow redirects
    RequestConfig requestconfig = RequestConfig.custom().setRedirectsEnabled(false).build();
    CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(requestconfig).build();
    try {
        HttpResponse response = client.execute(get);
        for (Header header : response.getAllHeaders()) {
            log.info("Header {}", header);
        }
        assertEquals(302, response.getStatusLine().getStatusCode());
        assertTrue("Should have location header", response.containsHeader("Location"));
        assertEquals("http://somewhere.com", response.getFirstHeader("Location").getValue());
        assertEquals("bar", response.getFirstHeader("Foo").getValue());
    } finally {
        client.close();
    }
}

public void execute(Tuple tuple) {
    String filterId = tuple.getStringByField("filter_id");
    long ts = tuple.getLongByField("timestamp");
    double score = tuple.getDoubleByField("score");
    String jsonDetails = tuple.getStringByField("json_details");
    LOG.info(filterId + " " + ts + " " + score + " " + jsonDetails);
    // Send to supervisor
    try {
        HttpClient client = HttpClientBuilder.create().build();
        String url = settings.get("supervisor_host") + "filter/" + filterId + "/outlier?timestamp=" + ts + "&score=" + score;
        HttpPost req = new HttpPost(url);
        req.setEntity(new StringEntity(jsonDetails));
        String token = new String(Base64.encodeBase64((settings.get("supervisor_username") + ":" + settings.get("supervisor_password")).getBytes()));
        req.setHeader("Authorization", "Basic " + token);
        HttpResponse resp = client.execute(req);
        int status = resp.getStatusLine().getStatusCode();
        if (status >= 400) {
            throw new Exception("Invalid status " + status);
        }
    } catch (Exception e) {
        LOG.error("Failed to write data to supervisor", e);
    }
    _collector.ack(tuple);
}

@Override
public Optional<String> getLatestVersionNumber(String currentVersion, boolean isScheduled) {
    HttpClient client = HttpClientBuilder.create().build();
    try {
        LOGGER.info("Fetching latest version number of eHour release from " + versionUrl);
        HttpGet request = new HttpGet(versionUrl);
        request.setHeader("User-Agent", String.format("%s eHour update client v%s", isScheduled ? "Scheduled" : "Bootstrap", currentVersion));
        BasicResponseHandler responseHandler = new BasicResponseHandler();
        String response = client.execute(request, responseHandler);
        return Optional.of(response);
    } catch (Exception e) {
        LOGGER.info("Failed to retrieve latest published eHour version: " + e.getMessage());
    }
    return Optional.absent();
}

//    @Test
public void download() {
    String url = "http://103.7.29.197/vweixinp.tc.qq.com/1007_efd683683fdd41ea9a999ea9ad81f239.f10.mp4?vkey=E79319C2D663CACB3A26812DBE3DC05F33EE92DEA914480FB88A77EF92832D1EDA51FFD2B275A7E9&sha=0&save=1";
    RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(NetWorkCenter.CONNECT_TIMEOUT).setConnectTimeout(NetWorkCenter.CONNECT_TIMEOUT).setSocketTimeout(NetWorkCenter.CONNECT_TIMEOUT).build();
    CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
    HttpGet get = new HttpGet(url);
    try {
        CloseableHttpResponse r = client.execute(get);
        LOG.debug("Status code: " + r.getStatusLine().getStatusCode());
        if (HttpStatus.SC_OK == r.getStatusLine().getStatusCode()) {
            InputStream inputStream = r.getEntity().getContent();
            Header[] headers = r.getHeaders("Content-disposition");
            if (null != headers && 0 != headers.length) {
                Header length = r.getHeaders("Content-Length")[0];
            }
        }
    } catch (IOException e) {
        LOG.error("IO异常处�", e);
    }
}

public static String upload(byte[] b, String ext, String mime) throws Exception {
    HttpClient httpclient = HttpClientBuilder.create().build();
    HttpPost httppost = new HttpPost("https://minfil.org/api/upload");
    MultipartEntityBuilder reqEntity = MultipartEntityBuilder.create();
    reqEntity.setMode(HttpMultipartMode.BROWSER_COMPATIBLE).addBinaryBody("minfil", b, ContentType.create(mime), "image." + ext);
    httppost.setEntity(reqEntity.build());
    HttpResponse response = httpclient.execute(httppost);
    String str = EntityUtils.toString(response.getEntity());
    return str;
}

public static boolean commitJsonDataToSolr(String solrCollection, String content) {
    try {
        HttpClient httpClient = HttpClientBuilder.create().build();
        HttpPost post = new HttpPost(solrCollection + "/update?commit=true");
        StringEntity entity = new StringEntity(content, "UTF-8");
        entity.setContentType("application/json");
        post.setEntity(entity);
        HttpResponse response = httpClient.execute(post);
        System.out.println(post.toString());
        System.out.println("Content: " + content);
        System.out.println("Status: " + response.getStatusLine().getStatusCode());
        if (200 == response.getStatusLine().getStatusCode()) {
            return true;
        }
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

public static void main(String[] args) {
    /*
       * This is out ot date - Just keeping
       * it in case it's helpful...
       */
    final String authUser = "username";
    final String authPassword = "password";
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(new AuthScope("10.10.10.10", 8080), new UsernamePasswordCredentials(authUser, authPassword));
    HttpHost myProxy = new HttpHost("10.10.10.10", 8080);
    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    clientBuilder.setProxy(myProxy).setProxyAuthenticationStrategy(new ProxyAuthenticationStrategy()).setDefaultCredentialsProvider(credsProvider).disableCookieManagement();
    CloseableHttpClient httpClient = clientBuilder.build();
    FhirContext ctx = FhirContext.forDstu2();
    String serverBase = "http://spark.furore.com/fhir/";
    ctx.getRestfulClientFactory().setHttpClient(httpClient);
    IGenericClient client = ctx.newRestfulGenericClient(serverBase);
    IdDt id = new IdDt("Patient", "123");
    client.read(Patient.class, id);
}

static int httpJsonPost(String newHttpPostUrl, String jsonData) throws IOException, ParseException {
    HttpClient client = HttpClientBuilder.create().build();
    HttpPost post = new HttpPost(newHttpPostUrl);
    StringEntity requestEntity = new StringEntity(jsonData, ContentType.APPLICATION_JSON);
    post.setEntity(requestEntity);
    HttpResponse response = client.execute(post);
    return response.getStatusLine().getStatusCode();
}

/**
	 * Create a http client with username / password authentication.
	 * If the argument is null, an http client without authentication is returned.
	 *
	 * @param credentials
	 * @return
	 */
public static HttpClientBuilder prepareHttpClientBuilder(UsernamePasswordCredentials credentials) {
    HttpClientBuilder result = HttpClientBuilder.create();
    if (credentials != null) {
        CredentialsProvider provider = new BasicCredentialsProvider();
        provider.setCredentials(AuthScope.ANY, credentials);
        result.setDefaultCredentialsProvider(provider);
    }
    return result;
}

public static void main(String[] args) throws RedditOAuthException, ParseException, RedditParseException {
    /********************************************
         * Initialization
        */
    // Information about the app
    String userAgent = "jReddit: Reddit API Wrapper for Java";
    String clientID = "PfnhLt3VahLrbg";
    String redirectURI = "https://github.com/snkas/jReddit";
    // Reddit application
    RedditApp redditApp = new RedditInstalledApp(clientID, redirectURI);
    // Create OAuth agent
    RedditOAuthAgent agent = new RedditOAuthAgent(userAgent, redditApp);
    // Create request executor 
    RedditClient client = new RedditHttpClient(userAgent, HttpClientBuilder.create().build());
    /********************************************
         * Perform requests in a loop
        */
    // Create token (will be valid for 1 hour)
    RedditToken token = agent.tokenAppOnly(false);
    // Create parser for request
    SubredditsListingParser parser = new SubredditsListingParser();
    // Create the request
    SubredditsOfUserRequest request = (SubredditsOfUserRequest) new SubredditsOfUserRequest(SubredditsView.NEW).setLimit(100);
    // Let's assume we want to show the results every 10 minutes
    long lastShow = 0;
    while (true) {
        // Create a new token if the current has expired or will expire very soon (e.g. 100s)
        if (token.isExpired() || token.willExpireIn(100)) {
            token = agent.tokenAppOnly(false);
        }
        // Every 10 minutes = 600 seconds = 600000 milliseconds
        if (System.currentTimeMillis() - lastShow > 600000) {
            // Perform and parse request, and store parsed result
            List<Subreddit> subreddits = parser.parse(client.get(token, request));
            // Now print out the result (don't care about formatting)
            System.out.println(subreddits);
            // Result shown, wait for next time
            lastShow = System.currentTimeMillis();
        }
    }
}

@Test
public void testSatisfied() throws Exception {
    driver.get(applicationURL().toString());
    WebElement element = driver.findElement(By.tagName("script"));
    String assetURI = element.getAttribute("src");
    assertNotNull(assetURI);
    HttpClient client = HttpClientBuilder.create().build();
    // With no etag
    HttpGet get = new HttpGet(assetURI);
    HttpResponse response = client.execute(get);
    assertEquals(200, response.getStatusLine().getStatusCode());
    assertEquals("a = 0;", EntityUtils.toString(response.getEntity()));
    Header[] etag = response.getHeaders("ETag");
    assertNotNull(etag);
    assertEquals(1, etag.length);
    // With correct etag
    get = new HttpGet(assetURI);
    get.setHeader("If-None-Match", etag[0].getValue());
    response = client.execute(get);
    assertEquals(304, response.getStatusLine().getStatusCode());
    assertEquals(null, response.getEntity());
    // With wrong etag
    get = new HttpGet(assetURI);
    get.setHeader("If-None-Match", "foo");
    response = client.execute(get);
    assertEquals(200, response.getStatusLine().getStatusCode());
    assertEquals("a = 0;", EntityUtils.toString(response.getEntity()));
    etag = response.getHeaders("ETag");
    assertNotNull(etag);
}

protected HttpClient createHttpClient() throws IOException {
    String proxyHost = System.getProperty("http.proxyHost");
    HttpHost proxy = null;
    if (proxyHost != null) {
        int proxyPort = Integer.parseInt(System.getProperty("http.proxyPort"));
        proxy = new HttpHost(proxyHost, proxyPort);
    }
    String userAgent = getUserAgent();
    HttpClientBuilder builder = HttpClientBuilder.create().setUserAgent(userAgent);
    if (proxy != null) {
        builder.setProxy(proxy);
    }
    return builder.build();
}

private void check() {
    try {
        RequestConfig globalConfig = RequestConfig.custom().setCircularRedirectsAllowed(true).build();
        CloseableHttpClient httpclient = HttpClientBuilder.create().build();
        logger.debug("Requesting: " + MANIFEST_URL);
        HttpGet httpGet = new HttpGet(MANIFEST_URL);
        httpGet.setConfig(globalConfig);
        CloseableHttpResponse response = httpclient.execute(httpGet);
        try {
            HttpEntity entity = response.getEntity();
            String htmlContent = EntityUtils.toString(entity);
            EntityUtils.consume(entity);
            Gson gson = new Gson();
            VersionInfo versionInfo = gson.fromJson(htmlContent, VersionInfo.class);
            if (versionInfo.isNewerVersionAvailable(BuildConfig.VERSION)) {
                logger.debug("Newer version available: {}" + versionInfo.version);
                getFacade().sendNotification(GameNotification.NEW_VERSION_AVAILABLE, versionInfo);
            } else {
                logger.debug("Version up-to-date");
            }
        } finally {
            response.close();
        }
    } catch (Exception e) {
        logger.warn("Auto updater version check failed: " + e.toString());
    }
}

public static HttpActionClient create_client(String session_name, String session, URL url) {
    HttpClientBuilder builder = HttpClientBuilder.create();
    builder.setUserAgent("missingBot/1.1");
    CookieStore cookieStore = new BasicCookieStore();
    BasicClientCookie c1 = new BasicClientCookie(session_name + "_session", session);
    c1.setDomain(url.getHost());
    cookieStore.addCookie(c1);
    builder.setDefaultCookieStore(cookieStore);
    return new HttpActionClient(builder, url);
}

@EventHandler
public void registerMappacks(RegisterMappacksEvent event) {
    HttpClient httpClient = HttpClientBuilder.create().build();
    try {
        HttpGet request = new HttpGet("http://nmm.jk-5.nl/mappacks.json");
        HttpResponse response = httpClient.execute(request);
        MappacksList list = gson.fromJson(EntityUtils.toString(response.getEntity(), "UTF-8"), MappacksList.class);
        for (String mappack : list.mappacks) {
            event.registerMappack(new NmmMappack(mappack));
        }
        logger.info("Registered " + list.mappacks.length + " nmm mappacks");
    } catch (Exception e) {
        logger.warn("Was not able to fetch mappacks from nmm.jk-5.nl", e);
    }
}

public Properties getProperties() {
    if (properties == null) {
        final Properties props = new Properties();
        try {
            try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {
                final HttpGet request = new HttpGet(url);
                request.setHeader("X-Nanobot-UUID", Settings.instance().getUuid().toString());
                request.setHeader("X-Nanobot-User", Settings.instance().getUserMailAddress());
                try (CloseableHttpResponse response = httpClient.execute(request)) {
                    final StatusLine statusLine = response.getStatusLine();
                    if (statusLine.getStatusCode() != HttpStatus.SC_OK) {
                        throw new IOException(statusLine.getStatusCode() + " " + statusLine.getReasonPhrase());
                    }
                    try (InputStream in = response.getEntity().getContent()) {
                        props.load(in);
                    }
                }
            }
        } catch (final IOException e) {
            throw new ExceptionInInitializerError(e);
        }
        properties = props;
    }
    return properties;
}

public static HttpClientBuilder getHTTPClientBuilder() {
    RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(Settings.TIMEOUT).setConnectTimeout(Settings.TIMEOUT).setSocketTimeout(Settings.TIMEOUT).build();
    HttpClientBuilder builder = HttpClientBuilder.create().setDefaultRequestConfig(config).setUserAgent("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36");
    return builder;
}

public static String sendRequest(String request) {
    String url = "https://api.twitch.tv/kraken/" + request;
    App.logger.info("Sent request: " + url);
    try {
        HttpClient client = HttpClientBuilder.create().build();
        HttpGet httpGet = new HttpGet(url);
        httpGet.addHeader("Accept", "application/vnd.twitchtv.v3+json");
        HttpResponse response = client.execute(httpGet);
        String responseStr = new BasicResponseHandler().handleResponse(response);
        App.logger.debug(responseStr);
        return responseStr;
    } catch (HttpResponseException e) {
        App.logger.error("Twitch API request failed.");
    } catch (IOException e) {
        App.logger.catching(e);
    }
    return null;
}

public void setCredentialsProvider(RfRequestDTO requestDTO, HttpClientBuilder clientBuilder) {
    DigestAuthDTO digestAuthDTO = requestDTO.getDigestAuthDTO();
    if (digestAuthDTO == null) {
        return;
    }
    String userName = digestAuthDTO.getUsername();
    String password = digestAuthDTO.getPassword();
    if (userName == null || userName.isEmpty() || password == null || password.isEmpty()) {
        return;
    }
    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope.ANY_REALM), new UsernamePasswordCredentials(userName, password));
    clientBuilder.setDefaultCredentialsProvider(credentialsProvider);
}

public static void recaptchaVerify(String secret, String captcha) throws RecaptchaException {
    BufferedReader bufferedReader = null;
    try {
        String urlParameters = "secret=" + secret + "&response=" + captcha;
        String url = "https://www.google.com/recaptcha/api/siteverify?" + urlParameters;
        String userAgent = "Mozilla/5.0";
        HttpClient client = HttpClientBuilder.create().build();
        HttpGet request = new HttpGet(url);
        request.addHeader("User-Agent", userAgent);
        HttpResponse response = client.execute(request);
        StringBuilder builder = new StringBuilder();
        bufferedReader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
        for (String line = null; (line = bufferedReader.readLine()) != null; ) {
            builder.append(line).append("\n");
        }
        JsonNode jsonObject = JsonUtils.parseJson(builder.toString());
        boolean success = jsonObject.get("success").asBoolean(false);
        if (!success) {
            throw new RecaptchaException("ReCAPTCHA verification failed");
        }
    } catch (Exception e) {
        throw new RecaptchaException("ReCAPTCHA verification failed", e);
    } finally {
        IOUtils.closeQuietly(bufferedReader);
    }
}

public String randomName() throws IOException {
    CloseableHttpClient httpclient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet("http://uinames.com/api/");
    CloseableHttpResponse response = httpclient.execute(httpGet);
    try {
        HttpEntity entity = response.getEntity();
        InputStream inputStream = entity.getContent();
        ObjectMapper mapper = new ObjectMapper();
        Map<String, String> jsonMap = mapper.readValue(inputStream, Map.class);
        String name = jsonMap.get("name");
        EntityUtils.consume(entity);
        return name;
    } finally {
        response.close();
    }
}

@Test
public void testReachable() throws ClientProtocolException, IOException {
    String secret = "secret452363763";
    HttpClient hc = HttpClientBuilder.create().build();
    HttpPost post = new HttpPost(getBaseURL());
    post.setEntity(new StringEntity(secret));
    HttpResponse res = hc.execute(post);
    assertEquals(200, res.getStatusLine().getStatusCode());
    AssertUtils.assertContains(secret, EntityUtils.toString(res.getEntity()));
}

@Override
public void customize(RestTemplate restTemplate) {
    HttpHost proxy = new HttpHost("proxy.example.com");
    HttpClient httpClient = HttpClientBuilder.create().setRoutePlanner(new DefaultProxyRoutePlanner(proxy) {

        @Override
        public HttpHost determineProxy(HttpHost target, HttpRequest request, HttpContext context) throws HttpException {
            if (target.getHostName().equals("192.168.0.5")) {
                return null;
            }
            return super.determineProxy(target, request, context);
        }
    }).build();
    restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient));
}

@NotNull
public GerritFacade build(Configuration configuration) {
    final ConnectorDetails connectorDetails = new ConnectorDetails(configuration);
    GerritPatchset gerritPatchset = buildGerritPatchset(configuration);
    GerritRestApiFactory gerritRestApiFactory = new GerritRestApiFactory();
    String hostUri = httpHelper.buildHttpHostUri(connectorDetails);
    if (!Strings.isNullOrEmpty(connectorDetails.getPath())) {
        hostUri += connectorDetails.getPath();
    }
    log.info("Using Gerrit URL: {}", hostUri);
    GerritAuthData.Basic authData = new GerritAuthData.Basic(hostUri, connectorDetails.getUsername(), connectorDetails.getPassword());
    GerritApi gerritApi = gerritRestApiFactory.create(authData, new HttpClientBuilderExtension() {

        @Override
        public HttpClientBuilder extend(HttpClientBuilder httpClientBuilder, GerritAuthData authData) {
            HttpClientBuilder clientBuilder = super.extend(httpClientBuilder, authData);
            clientBuilder.setSSLSocketFactory(httpHelper.buildSSLSocketFactory(connectorDetails));
            return clientBuilder;
        }
    });
    return new GerritFacade(gerritApi, gerritPatchset);
}

protected String fetchURLasString(String url) throws IOException, ParseException {
    HttpClient httpclient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet(url);
    HttpResponse response = httpclient.execute(httpGet);
    HttpEntity entity = response.getEntity();
    String body = EntityUtils.toString(entity);
    EntityUtils.consume(entity);
    //httpGet.releaseConnection();
    return body;
}

public HttpClient create() {
    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    if (proxySettings.getUrl() != null) {
        URL proxyUrl = proxySettings.getUrl();
        HttpHost proxyHost = new HttpHost(proxyUrl.getHost(), proxyUrl.getPort(), proxyUrl.getProtocol());
        clientBuilder.setProxy(proxyHost);
    }
    return clientBuilder.build();
}

@Test
public void testTestServer() throws Exception {
    // Test parameters
    String expectedResponse = "<h1>Hello World</h1>";
    int expectedStatusCode = HttpServletResponse.SC_OK;
    int port = 8080;
    URI uri = new URI(String.format("http://localhost:%s/", port));
    // Setup
    SimpleServer server = new SimpleServer(port, new SimpleHandler(expectedResponse, expectedStatusCode));
    server.start();
    // Make request
    HttpClient client = HttpClientBuilder.create().build();
    HttpGet getRequest = new HttpGet(uri.toString());
    HttpResponse getResponse = client.execute(getRequest);
    int actualStatusCode = getResponse.getStatusLine().getStatusCode();
    String actualResponse = EntityUtils.toString(getResponse.getEntity());
    // Clean up
    server.stop();
    // Test
    assertEquals(expectedStatusCode, actualStatusCode);
    assertEquals(expectedResponse, actualResponse);
}

@Override
public void clearWebhook() throws TelegramApiRequestException {
    try (CloseableHttpClient httpclient = HttpClientBuilder.create().setSSLHostnameVerifier(new NoopHostnameVerifier()).build()) {
        String url = ApiConstants.BASE_URL + getBotToken() + "/" + SetWebhook.PATH;
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(getOptions().getRequestConfig());
        try (CloseableHttpResponse response = httpclient.execute(httpGet)) {
            HttpEntity ht = response.getEntity();
            BufferedHttpEntity buf = new BufferedHttpEntity(ht);
            String responseContent = EntityUtils.toString(buf, StandardCharsets.UTF_8);
            JSONObject jsonObject = new JSONObject(responseContent);
            if (!jsonObject.getBoolean(ApiConstants.RESPONSE_FIELD_OK)) {
                throw new TelegramApiRequestException("Error removing old webhook", jsonObject);
            }
        }
    } catch (JSONException e) {
        throw new TelegramApiRequestException("Error deserializing setWebhook method response", e);
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error executing setWebook method", e);
    }
}

@Override
public void clearWebhook() throws TelegramApiRequestException {
    try (CloseableHttpClient httpclient = HttpClientBuilder.create().setSSLHostnameVerifier(new NoopHostnameVerifier()).build()) {
        String url = ApiConstants.BASE_URL + getBotToken() + "/" + SetWebhook.PATH;
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(getOptions().getRequestConfig());
        try (CloseableHttpResponse response = httpclient.execute(httpGet)) {
            HttpEntity ht = response.getEntity();
            BufferedHttpEntity buf = new BufferedHttpEntity(ht);
            String responseContent = EntityUtils.toString(buf, StandardCharsets.UTF_8);
            JSONObject jsonObject = new JSONObject(responseContent);
            if (!jsonObject.getBoolean(ApiConstants.RESPONSE_FIELD_OK)) {
                throw new TelegramApiRequestException("Error removing old webhook", jsonObject);
            }
        }
    } catch (JSONException e) {
        throw new TelegramApiRequestException("Error deserializing setWebhook method response", e);
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error executing setWebook method", e);
    }
}

@Test
public void simpleTest() throws IOException {
    String address = String.format("http://%s:%s", container.getContainerIpAddress(), container.getMappedPort(80));
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    HttpGet get = new HttpGet(address);
    Unreliables.retryUntilSuccess(5, TimeUnit.SECONDS, () -> {
        try (CloseableHttpResponse response = httpClient.execute(get)) {
            assertEquals("A container built from a dockerfile can run nginx as expected, and returns a good status code", 200, response.getStatusLine().getStatusCode());
            assertTrue("A container built from a dockerfile can run nginx as expected, and returns an expected Server header", response.getHeaders("Server")[0].getValue().contains("nginx"));
        }
        return true;
    });
}

/**
	 * Creates a HttpClientBuilder object with the proxy settings if they are configured
	 * 
	 * @param useProxyIfAvailable
	 * if the proxy settings are available, this connection will be initiated using the configured
	 * proxy
	 * @param trustSelfSignedCertificates
	 * whether or not self signed certificates should be trusted
	 * @return a CloseableHttpClient
	 */
public static HttpClientBuilder createClientBuilder(final boolean useProxyIfAvailable, final boolean trustSelfSignedCertificates) {
    if (useProxyIfAvailable) {
        String proxyHost = SdkAppConfig.getInstance().getTcProxyHost();
        Integer proxyPort = SdkAppConfig.getInstance().getTcProxyPort();
        String proxyUserName = SdkAppConfig.getInstance().getTcProxyUsername();
        String proxyPassword = SdkAppConfig.getInstance().getTcProxyPassword();
        logger.debug(String.format("creating http client with proxy setings http://%s:%s %s:%s", proxyHost, proxyPort, proxyUserName, proxyPassword));
        return ConnectionUtil.createClientBuilder(proxyHost, proxyPort, proxyUserName, proxyPassword, trustSelfSignedCertificates);
    } else {
        logger.debug("Creating http client without proxy settings");
        return ConnectionUtil.createClientBuilder(null, null, null, null, trustSelfSignedCertificates);
    }
}

public static void refresh() {
    // Load timeouts
    Object connectionTimeout = Options.getOption(Option.CONNECTION_TIMEOUT);
    if (connectionTimeout == null)
        connectionTimeout = CONNECTION_TIMEOUT;
    Object socketTimeout = Options.getOption(Option.SOCKET_TIMEOUT);
    if (socketTimeout == null)
        socketTimeout = SOCKET_TIMEOUT;
    // Create common default configuration
    RequestConfig clientConfig = RequestConfig.custom().setConnectTimeout(((Long) connectionTimeout).intValue()).setSocketTimeout(((Long) socketTimeout).intValue()).setConnectionRequestTimeout(((Long) socketTimeout).intValue()).build();
    // Create clients
    setOption(Option.HTTPCLIENT, HttpClientBuilder.create().setDefaultRequestConfig(clientConfig).build());
    CloseableHttpAsyncClient asyncClient = HttpAsyncClientBuilder.create().setDefaultRequestConfig(clientConfig).build();
    setOption(Option.ASYNCHTTPCLIENT, asyncClient);
}

// Build up URL and copy over query parameters:		
public static Result passthrough(String url) throws ClientProtocolException, IOException {
    // Build up the wayback query:
    String urlBuilder = url;
    String q = ctx()._requestHeader().rawQueryString();
    if (q != null && q.length() > 0) {
        Logger.info("Passing through raw Query String: " + q);
        urlBuilder += "?" + q;
    }
    final String nurl = urlBuilder;
    Logger.info("Proxing " + nurl);
    // Set up the GET:
    CloseableHttpClient httpclient = HttpClientBuilder.create().disableRedirectHandling().build();
    HttpGet httpGet = new HttpGet(nurl);
    CloseableHttpResponse response = httpclient.execute(httpGet);
    // If this looks like a redirect, return that:
    if (response.getFirstHeader(LOCATION) != null) {
        String location = response.getFirstHeader(LOCATION).getValue();
        response.close();
        Logger.info("Got LOCATION: " + location);
        // Issue the redirect directly...
        return redirect(location);
    }
    // Pass the content type over:
    String contentType = response.getFirstHeader(CONTENT_TYPE).getValue();
    Logger.debug("Response content type: " + contentType);
    HttpEntity entity = response.getEntity();
    return status(response.getStatusLine().getStatusCode(), entity.getContent()).as(contentType);
}

public static void main(String[] args) throws IOException, ScriptException {
    // set up simple logging
    Log.wireUp();
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    ScriptEngine engine = scriptEngineManager.getEngineByName("JavaScript");
    engine.eval("var event = {\"created_at\":\"2014-01-08T12:35:01-08:00\",\"alert_policy_name\":\"Key Transactions\",\"account_name\":\"NewRelic Administration\",\"severity\":\"critical\",\"message\":\"'BeaconServiceServlet/getAccountInformation' Apdex score < 0.7\",\"short_description\":\"Ended alert for Key Transactions: 'BeaconServiceServlet/getAccountInformation' Apdex score < 0.7\",\"long_description\":\"Alert ended for Key Transactions -- Triggered by: 'BeaconServiceServlet/getAccountInformation' Apdex score < 0.7 -- Key transactions currently involved: BeaconServiceServlet/getAccountInformation, Plugin Components Index, APIv2: Applications Index, KT test Transaction\",\"alert_url\":\"https://dev.newrelic.com/accounts/1/incidents/13861\"}\n");
    engine.put("log", new Log("script.js"));
    engine.put("utils", new Utils());
    engine.put("http", new HttpClient(HttpClientBuilder.create().build(), engine));
    engine.eval("var console = {log: function(msg) { log.info(msg); }}");
    engine.eval("log.info('foo', 'bar', 'baz')");
}

public WeedFSClient build() {
    if (masterUrl == null) {
        try {
            // default url for testing purpose
            masterUrl = new URL("http://localhost:9333");
        } catch (MalformedURLException e) {
            throw new Error(e);
        }
    }
    if (httpClient == null) {
        // minimal http client
        httpClient = HttpClientBuilder.create().build();
    }
    return new WeedFSClientImpl(masterUrl, httpClient, lookupCache);
}

@Test
@Ignore
public void testPostMsgText() throws ClientProtocolException, IOException {
    HttpClient httpclient = HttpClientBuilder.create().build();
    HttpPost httppost = new HttpPost(WX_URL);
    // Request parameters and other properties.
    List<NameValuePair> params = new ArrayList<NameValuePair>(2);
    params.add(new BasicNameValuePair("signature", "38f004a5f222473f3abd85fd8e4b1de2349119c6"));
    params.add(new BasicNameValuePair("timestamp", "1375192987"));
    params.add(new BasicNameValuePair("nonce", "1374785014"));
    httppost.setEntity(new StringEntity(WxXMLUtilTest.MSG_TEXT_XML));
    //Execute and get the response.
    HttpResponse response = httpclient.execute(httppost);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        InputStream instream = entity.getContent();
        try {
            String result = IOUtils.toString(instream);
            System.out.println(result);
        } finally {
            instream.close();
        }
    }
}

@Test
@Ignore
public void testPostMsgText() throws ClientProtocolException, IOException {
    HttpClient httpclient = HttpClientBuilder.create().build();
    HttpPost httppost = new HttpPost(WX_URL);
    // Request parameters and other properties.
    List<NameValuePair> params = new ArrayList<NameValuePair>(2);
    params.add(new BasicNameValuePair("signature", "38f004a5f222473f3abd85fd8e4b1de2349119c6"));
    params.add(new BasicNameValuePair("timestamp", "1375192987"));
    params.add(new BasicNameValuePair("nonce", "1374785014"));
    httppost.setEntity(new StringEntity(WxXMLUtilTest.MSG_TEXT_XML));
    //Execute and get the response.
    HttpResponse response = httpclient.execute(httppost);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        InputStream instream = entity.getContent();
        try {
            String result = IOUtils.toString(instream);
            System.out.println(result);
        } finally {
            instream.close();
        }
    }
}

protected Map<?, ?> getDefinedServicesAsMap() throws IOException {
    HttpClientBuilder builder = HttpClientBuilder.create();
    CloseableHttpClient client = builder.build();
    HttpUriRequest request = new HttpGet(servicesUrl);
    CloseableHttpResponse response = client.execute(request);
    assertThat(response.getStatusLine().getStatusCode()).isEqualTo(200);
    String content = EntityUtils.toString(response.getEntity());
    return mapper.readValue(content, Map.class);
}

public static String getJsonFromUrl(String url) {
    HttpClient httpclient = HttpClientBuilder.create().build();
    HttpGet httpget = new HttpGet(url);
    httpget.addHeader("X-TBA-App-Id", "frc111:scouting-system-desktop:v1.0");
    InputStream inputStream = null;
    String result = null;
    try {
        HttpResponse response = httpclient.execute(httpget);
        HttpEntity entity = response.getEntity();
        inputStream = entity.getContent();
        // json is UTF-8 by default
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"), 8);
        StringBuilder sb = new StringBuilder();
        String line = null;
        while ((line = reader.readLine()) != null) {
            sb.append(line + "\n");
        }
        result = sb.toString();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (inputStream != null)
                inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return result;
}

@Override
protected CloseableHttpClient performLoginIfNecessary(HttpClientBuilder clientBuilder, List<Header> requestHeaders) throws Exception {
    SettingsUtil.Settings settings = SettingsUtil.loadSettings();
    if (client == null || accessToken == null || new Date().after(accessToken.getExpirationDate()) || (connectionParameterHashCode != null && !connectionParameterHashCode.equals(settings.getConnectionParametersHashCode()))) {
        LOGGER.info("Fetching new access token");
        try {
            URL hubUrl = new URL(settings.getYoutrackOAuthHubUrl());
            HubClient hubClient = HubClient.builder().baseUrl(hubUrl).build();
            OAuth2Client oAuthClient = hubClient.getOAuthClient();
            OAuth2ResourceOwnerFlow flow = oAuthClient.resourceOwnerFlow().clientId(settings.getYoutrackOAuthServiceId()).clientSecret(settings.getYoutrackOAuthServiceSecret()).username(settings.getYoutrackUsername()).password(settings.getYoutrackPassword()).addScope(YOUTRACK_SCOPE).build();
            accessToken = flow.getToken();
            if (accessToken == null) {
                throw ExceptionUtil.getIllegalStateException("exceptions.oauth.couldnotobtainaccesstoken");
            }
            LOGGER.debug("Setting AccessToken");
            String requestHeaderValue = String.format("%s %s", accessToken.getType(), accessToken.encode());
            requestHeaders.add(new BasicHeader("Authorization", requestHeaderValue));
            // everythings fine
            // set headers and initialize client
            connectionParameterHashCode = settings.getConnectionParametersHashCode();
            client = clientBuilder.setDefaultHeaders(requestHeaders).build();
        } catch (MalformedURLException e) {
            LOGGER.error("Malformed URL", e);
            throw ExceptionUtil.getIllegalArgumentException("exceptions.main.oauth2.huburl", e);
        }
    }
    return client;
}

@Before
public void setUp() {
    final MetricRegistry metricRegistry = new MetricRegistry();
    configuration = new HttpClientConfiguration();
    builder = new HttpClientBuilder(metricRegistry);
    connectionManager = spy(new InstrumentedHttpClientConnectionManager(metricRegistry, registry));
    apacheBuilder = org.apache.http.impl.client.HttpClientBuilder.create();
    initMocks(this);
}

@Before
public void setUp() {
    final MetricRegistry metricRegistry = new MetricRegistry();
    configuration = new HttpClientConfiguration();
    builder = new HttpClientBuilder(metricRegistry);
    connectionManager = spy(new InstrumentedHttpClientConnectionManager(metricRegistry, registry));
    apacheBuilder = org.apache.http.impl.client.HttpClientBuilder.create();
    initMocks(this);
}

/**
     * Get an HttpClient given a proxy config if any
     * @param proxyConfiguration configuration of proxy to use
     * @return org.apache.http.impl.client.CloseableHttpClient
     */
CloseableHttpClient getHttpClient(final ProxyConfiguration proxyConfiguration) {
    HttpClientBuilder httpClientBuilder = getHttpClientBuilder();
    if (proxyAuthenticationRequired(proxyConfiguration)) {
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(new AuthScope(proxyConfiguration.getHost(), proxyConfiguration.getPort()), new UsernamePasswordCredentials(proxyConfiguration.getUsername(), proxyConfiguration.getPassword()));
        httpClientBuilder = httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    }
    return httpClientBuilder.build();
}

public static Collection<Developer> fetchDevelopers(ProgressIndicator indicator) throws IOException {
    RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(1000).build();
    try (CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).build()) {
        return client.execute(new HttpGet(DEVELOPERS_LIST_URL),  response -> {
            List<Developer> developers = new LinkedList<Developer>();
            developers.add(Developer.NULL);
            HttpEntity entity = response.getEntity();
            if (entity == null) {
                return developers;
            }
            BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent(), StandardCharsets.UTF_8));
            while (true) {
                String line = reader.readLine();
                if (line == null)
                    break;
                int i = line.indexOf('\t');
                if (i == -1)
                    throw new IOException("Protocol error");
                int id = Integer.parseInt(line.substring(0, i));
                String name = line.substring(i + 1);
                developers.add(new Developer(id, name));
                indicator.checkCanceled();
            }
            return developers;
        });
    }
}

public HTTPClient build() {
    StopWatch watch = new StopWatch();
    try {
        HttpClientBuilder builder = HttpClients.custom();
        builder.setUserAgent(userAgent);
        builder.setKeepAliveStrategy(( response,  context) -> keepAliveTimeout.toMillis());
        builder.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE).setSSLContext(new SSLContextBuilder().loadTrustMaterial(TrustSelfSignedStrategy.INSTANCE).build());
        // builder use PoolingHttpClientConnectionManager by default, and connTimeToLive will be set by keepAlive value
        builder.setDefaultSocketConfig(SocketConfig.custom().setSoKeepAlive(true).build());
        builder.setDefaultRequestConfig(RequestConfig.custom().setSocketTimeout((int) timeout.toMillis()).setConnectionRequestTimeout((int) timeout.toMillis()).setConnectTimeout((int) timeout.toMillis()).build());
        builder.setMaxConnPerRoute(maxConnections).setMaxConnTotal(maxConnections);
        builder.disableAuthCaching();
        builder.disableConnectionState();
        // retry should be handled in framework level with better trace log
        builder.disableAutomaticRetries();
        if (!enableRedirect)
            builder.disableRedirectHandling();
        if (!enableCookie)
            builder.disableCookieManagement();
        CloseableHttpClient httpClient = builder.build();
        return new HTTPClient(httpClient, userAgent, slowOperationThreshold);
    } catch (NoSuchAlgorithmExceptionKeyManagementException | KeyStoreException |  e) {
        throw new Error(e);
    } finally {
        logger.info("create http client, elapsedTime={}", watch.elapsedTime());
    }
}

private static HttpResponseResult makeRequest(HttpUriRequest request, Credentials credentials) throws IOException {
    HttpClientBuilder clientBuilder = HttpClients.custom();
    if (credentials != null) {
        CredentialsProvider credsProvider = prepareCredenitalsProvider(request.getURI(), credentials);
        clientBuilder.setDefaultCredentialsProvider(credsProvider);
    }
    CloseableHttpClient httpclient = clientBuilder.build();
    HttpResponseResult result = null;
    try {
        logger.debug("Executing request {}", request.getRequestLine());
        CloseableHttpResponse response = httpclient.execute(request);
        try {
            StatusLine statusLine = response.getStatusLine();
            result = new HttpResponseResult(statusLine);
            HttpEntity entity = response.getEntity();
            result.resultContent = EntityUtils.toString(entity);
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    } finally {
        httpclient.close();
    }
    return result;
}

public Document get(String path) {
    Document document = null;
    InputStream result = null;
    path = trimSlashes(path);
    String fullPath = url + '/' + path;
    HttpGet httpGet = new HttpGet(fullPath);
    try {
        HttpClient httpClient = HttpClientBuilder.create().build();
        HttpResponse getResponse = httpClient.execute(httpGet);
        //do not close this httpClient
        result = getResponse.getEntity().getContent();
        document = XMLUtils.convertStreamToXML(result);
    } catch (Exception e) {
        getGotError(e, fullPath);
    }
    return document;
}

public Document get(String path) {
    Document document = null;
    InputStream result = null;
    path = trimSlashes(path);
    String fullPath = url + '/' + path;
    HttpGet httpGet = new HttpGet(fullPath);
    try {
        HttpClient httpClient = HttpClientBuilder.create().build();
        HttpResponse getResponse = httpClient.execute(httpGet);
        //do not close this httpClient
        result = getResponse.getEntity().getContent();
        document = XMLUtils.convertStreamToXML(result);
    } catch (Exception e) {
        getGotError(e, fullPath);
    }
    return document;
}

public static void main(String[] args) throws IOException {
    // Step1 代�策略,确定那些请求将会被代�池代�
    WhiteListProxyStrategy whiteListProxyStrategy = new WhiteListProxyStrategy();
    whiteListProxyStrategy.addAllHost("58.com");
    //确定缓存文件�置,如果没有预热,�以�指定
    JSONFileAvProxyDumper jsonFileAvProxyDumper = new JSONFileAvProxyDumper();
    jsonFileAvProxyDumper.setDumpFileName("你的IP文件�置");
    // Step2 创建并定制代�规则
    DungProxyContext dungProxyContext = DungProxyContext.create().setNeedProxyStrategy(whiteListProxyStrategy).setAvProxyDumper(jsonFileAvProxyDumper);
    dungProxyContext.getGroupBindRouter().buildCombinationRule("58.com:.*58.com");
    // Step3 使用代�规则�始化默认IP池
    IpPoolHolder.init(DungProxyContext.create().setPoolEnabled(true));
    // step 4 将代�池注册到httpclient(两个为httpclient�的适��件)
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    httpClientBuilder.setRetryHandler(new DunProxyHttpRequestRetryHandler(null)).setRoutePlanner(new ProxyBindRoutPlanner());
    CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
    HttpGet httpGet = new HttpGet("http://www.baidu.com");
    CloseableHttpResponse response = closeableHttpClient.execute(httpGet);
    String string = IOUtils.toString(response.getEntity().getContent());
    System.out.println(string);
}

@Override
public void run() {
    try {
        // Prepare get parameters
        final String version = Version.getVersionName().replaceAll("\\s+", "");
        final String lang = I18N.getCurrentLanguage();
        final String url = String.format(URL, Eln.playerUUID, version, lang);
        // Send HTTP get request
        CloseableHttpClient client = HttpClientBuilder.create().build();
        CloseableHttpResponse response = client.execute(new HttpGet(url));
        final int repCode = response.getStatusLine().getStatusCode();
        if (repCode != HttpStatus.SC_OK)
            throw new IOException("HTTP error " + repCode);
        // Utils.println("URL: " + url);
        response.close();
        client.close();
    } catch (Exception e) {
        String error = "Unable to send analytics data: " + e.getMessage() + ".";
        System.err.println(error);
    }
    AnalyticsHandler.getInstance().ready = true;
}

public String getDataPage(final String address) throws IOException {
    final HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    final CloseableHttpClient httpclient = clientBuilder.build();
    final HttpGet request = new HttpGet(address);
    String result = null;
    try {
        request.setHeader("User-Agent", userAgent);
        final HttpResponse response = httpclient.execute(request);
        final StatusLine statusLine = response.getStatusLine();
        final int status = statusLine.getStatusCode();
        if ((status >= HttpStatus.SC_OK) && (status < HttpStatus.SC_MULTIPLE_CHOICES)) {
            final HttpEntity entity = response.getEntity();
            if (entity != null) {
                result = EntityUtils.toString(entity);
            }
        } else {
            if (LOGGER.isWarnEnabled()) {
                LOGGER.warn("Got " + status + " for the query " + address);
            }
        }
    } finally {
        request.reset();
        httpclient.close();
    }
    return result;
}

@Override
public CredentialsProvider extendCredentialProvider(HttpClientBuilder httpClientBuilder, CredentialsProvider credentialsProvider, GerritAuthData authData) {
    HttpConfigurable proxySettings = HttpConfigurable.getInstance();
    IdeaWideProxySelector ideaWideProxySelector = new IdeaWideProxySelector(proxySettings);
    // This will always return at least one proxy, which can be the "NO_PROXY" instance.
    List<Proxy> proxies = ideaWideProxySelector.select(URI.create(authData.getHost()));
    // Find the first real proxy with an address type we support.
    for (Proxy proxy : proxies) {
        SocketAddress socketAddress = proxy.address();
        if (HttpConfigurable.isRealProxy(proxy) && socketAddress instanceof InetSocketAddress) {
            InetSocketAddress address = (InetSocketAddress) socketAddress;
            HttpHost proxyHttpHost = new HttpHost(address.getHostName(), address.getPort());
            httpClientBuilder.setProxy(proxyHttpHost);
            // to use these credential but it's probably what the user expects.
            if (proxySettings.PROXY_AUTHENTICATION) {
                AuthScope authScope = new AuthScope(proxySettings.PROXY_HOST, proxySettings.PROXY_PORT);
                UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(proxySettings.PROXY_LOGIN, proxySettings.getPlainProxyPassword());
                credentialsProvider.setCredentials(authScope, credentials);
                break;
            }
        }
    }
    return credentialsProvider;
}

public CloseableHttpClient build() throws Exception {
    HttpClientBuilder builder = HttpClients.custom();
    builder.setDefaultSocketConfig(SocketConfig.custom().setTcpNoDelay(true).setSoKeepAlive(true).build()).setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE);
    HostnameVerifier hostnameVerifier = sslVerificationMode.verifier();
    TrustStrategy trustStrategy = sslVerificationMode.trustStrategy();
    KeyStore trustStore = agentTruststore();
    SSLContextBuilder sslContextBuilder = SSLContextBuilder.create().useProtocol(systemEnvironment.get(SystemEnvironment.GO_SSL_TRANSPORT_PROTOCOL_TO_BE_USED_BY_AGENT));
    if (trustStore != null || trustStrategy != null) {
        sslContextBuilder.loadTrustMaterial(trustStore, trustStrategy);
    }
    sslContextBuilder.loadKeyMaterial(agentKeystore(), keystorePassword().toCharArray());
    SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), hostnameVerifier);
    builder.setSSLSocketFactory(sslConnectionSocketFactory);
    return builder.build();
}

protected SimplifiedResponse post(String path, Map<String, String> formParameters) {
    List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
    for (Entry<String, String> entry : formParameters.entrySet()) {
        nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    }
    SimplifiedResponse responseToReturn = null;
    HttpClientBuilder clientBuilder = HttpClients.custom();
    try (CloseableHttpClient httpClient = clientBuilder.build()) {
        HttpPost request = new HttpPost("http://localhost:4204" + path);
        HttpEntity entity = new UrlEncodedFormEntity(nameValuePairs);
        request.setEntity(entity);
        try (CloseableHttpResponse response = httpClient.execute(request)) {
            responseToReturn = new SimplifiedResponse(response.getStatusLine().getStatusCode(), EntityUtils.toString(response.getEntity()));
        }
    } catch (IOException e) {
        new RuntimeException(e);
    }
    return responseToReturn;
}

public CloseableHttpClient configure(HttpClientBuilder builder, ResolverConfiguration configuration) {
    builder.disableAuthCaching();
    ConnectionConfiguration config = configuration.getConnectionConfiguration();
    builder.setConnectionManager(configurationManager(config));
    SocketConfig.Builder socketConfig = SocketConfig.copy(SocketConfig.DEFAULT);
    if (config.getSocketTimeout().isPresent()) {
        socketConfig.setSoTimeout(config.getSocketTimeout().get());
    }
    builder.setDefaultSocketConfig(socketConfig.build());
    ProxyAuthenticator proxyAuthenticator = configuration.getProxyAuthenticator();
    HTTPHost proxyHost = proxyAuthenticator.getConfiguration().getHost();
    RequestConfig requestC = requestConfig(proxyHost, config);
    builder.setDefaultRequestConfig(requestC);
    builder.setHttpProcessor(httpProcessor(configuration));
    return builder.build();
}

/*
	 * Path for method:
	 * "<server address>/TelcoReadyAppMFP/adapters/CloudantGeoAdapter/users/{user_id}/wifi"
	 */
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/{user_id}/wifi")
public Response getWifiLocations(@PathParam("user_id") String name, @QueryParam(value = "lat") double latitude, @QueryParam(value = "lon") double longitude) {
    GeoJsonPoint userLocation = new GeoJsonPoint(latitude, longitude);
    try {
        HttpGet httpget = new HttpGet(GeoRadiusURI.build(DEMO_LOCATION));
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpResponse httpResponse = httpClient.execute(httpget);
        if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.OK.getCode()) {
            String jsonString = EntityUtils.toString(httpResponse.getEntity());
            List<WifiHotspotFlat> hotspots = WifiHotspotUtils.parseAndOffsetHotspots(jsonString, userLocation);
            return Response.ok(new Gson().toJson(hotspots), MediaType.APPLICATION_JSON).build();
        }
        httpClient.close();
        return Response.serverError().entity(httpResponse.getStatusLine()).build();
    } catch (URISyntaxExceptionParseException | IOException |  e) {
        e.printStackTrace();
        return Response.serverError().entity("Error").build();
    }
}

@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
    String trackingId = System.getenv("GA_TRACKING_ID");
    HttpClient client = HttpClientBuilder.create().build();
    URIBuilder builder = new URIBuilder();
    builder.setScheme("http").setHost("www.google-analytics.com").setPath("/collect").addParameter("v", // API Version.
    "1").addParameter("tid", // Tracking ID / Property ID.
    trackingId).addParameter(// is associated with particular user, device, or browser instance.
    "cid", "555").addParameter("t", // Event hit type.
    "event").addParameter("ec", // Event category.
    "example").addParameter("ea", // Event action.
    "test action");
    URI uri = null;
    try {
        uri = builder.build();
    } catch (URISyntaxException e) {
        throw new ServletException("Problem building URI", e);
    }
    HttpPost request = new HttpPost(uri);
    client.execute(request);
    resp.getWriter().println("Event tracked.");
}

@Before
public void setUp() throws Exception {
    client = new TrelloClient(new TrelloPluginConfig("https://trello.com"), 1L, new HttpClientFactory() {

        @Override
        public HttpClient getHttpClient() {
            return HttpClientBuilder.create().build();
        }

        @Override
        public HttpClient getBasicAuthHttpClient(URL url, String user, String password) throws MalformedURLException {
            return getHttpClient();
        }
    });
}

public void authenticate(HttpClientBuilder pBuilder, String pUser, String pPassword) {
    // Preparing the builder for the credentials
    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(new AuthScope(AuthScope.ANY), new UsernamePasswordCredentials(pUser, pPassword));
    pBuilder.setDefaultCredentialsProvider(credentialsProvider);
    if (preemptive) {
        pBuilder.addInterceptorFirst(new PreemptiveAuthInterceptor(new BasicScheme()));
    }
}

private CloseableHttpClient buildClient(Config config) {
    HttpClientBuilder cb = HttpClientBuilder.create().setUserAgent(USER_AGENT);
    if (config.getProxy() != null) {
        try {
            URL url = new URL(config.getProxy().getHost());
            HttpHost proxy = new HttpHost(url.getHost(), config.getProxy().getPort(), url.getProtocol());
            cb.setProxy(proxy);
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    if (config.isIgnoreSSLVerification()) {
        cb.setSslcontext(UntrustedSSL.getSSLContext());
        cb.setHostnameVerifier(new AllowAllHostnameVerifier());
    }
    if (config.getSslContext() != null)
        cb.setSslcontext(config.getSslContext());
    if (config.getMaxConnections() > 0) {
        cb.setMaxConnTotal(config.getMaxConnections());
    }
    if (config.getMaxConnectionsPerRoute() > 0) {
        cb.setMaxConnPerRoute(config.getMaxConnectionsPerRoute());
    }
    RequestConfig.Builder rcb = RequestConfig.custom();
    if (config.getConnectTimeout() > 0)
        rcb.setConnectTimeout(config.getConnectTimeout());
    if (config.getReadTimeout() > 0)
        rcb.setSocketTimeout(config.getReadTimeout());
    if (INTERCEPTOR != null) {
        INTERCEPTOR.onClientCreate(cb, rcb, config);
    }
    return cb.setDefaultRequestConfig(rcb.build()).build();
}

@Test
public void testPlayer() throws Exception {
    // Media Pipeline
    MediaPipeline mp = pipelineFactory.create();
    PlayerEndpoint playerEP = mp.newPlayerEndpoint("http://files.kurento.org/video/small.webm").build();
    HttpGetEndpoint httpEP = mp.newHttpGetEndpoint().terminateOnEOS().build();
    playerEP.connect(httpEP);
    playerEP.play();
    // Test execution
    HttpClient client = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet(httpEP.getUrl());
    HttpResponse response = client.execute(httpGet);
    HttpEntity resEntity = response.getEntity();
    // Assertions
    Assert.assertEquals("Response content-type must be video/webm", "video/webm", resEntity.getContentType().getValue());
}

public String getResponse() throws IOException, URISyntaxException {
    String response = "";
    // HttpClient httpclient = HttpClients.createDefault();
    HttpPost httppost = new HttpPost(url.toURI());
    RequestConfig config = RequestConfig.custom().setConnectTimeout(TIMEOUT_VALUE / 2).setConnectionRequestTimeout(TIMEOUT_VALUE).setSocketTimeout(4 * TIMEOUT_VALUE).build();
    CloseableHttpClient httpclient = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
    try {
        httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    /*
		 * Execute the HTTP Request
		 */
    try {
        HttpResponse httpresponse = httpclient.execute(httppost);
        HttpEntity respEntity = httpresponse.getEntity();
        if (respEntity != null) {
            // EntityUtils to get the response content
            response += EntityUtils.toString(respEntity);
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    httpclient.close();
    return response;
}

private CloseableHttpClient buildClient(Config config) {
    HttpClientBuilder cb = HttpClientBuilder.create().setUserAgent(USER_AGENT);
    if (config.getProxy() != null) {
        try {
            URL url = new URL(config.getProxy().getHost());
            HttpHost proxy = new HttpHost(url.getHost(), config.getProxy().getPort(), url.getProtocol());
            cb.setProxy(proxy);
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    if (config.isIgnoreSSLVerification()) {
        cb.setSslcontext(UntrustedSSL.getSSLContext());
        cb.setHostnameVerifier(new AllowAllHostnameVerifier());
    }
    if (config.getSslContext() != null)
        cb.setSslcontext(config.getSslContext());
    if (config.getMaxConnections() > 0) {
        cb.setMaxConnTotal(config.getMaxConnections());
    }
    if (config.getMaxConnectionsPerRoute() > 0) {
        cb.setMaxConnPerRoute(config.getMaxConnectionsPerRoute());
    }
    RequestConfig.Builder rcb = RequestConfig.custom();
    if (config.getConnectTimeout() > 0)
        rcb.setConnectTimeout(config.getConnectTimeout());
    if (config.getReadTimeout() > 0)
        rcb.setSocketTimeout(config.getReadTimeout());
    if (INTERCEPTOR != null) {
        INTERCEPTOR.onClientCreate(cb, rcb, config);
    }
    return cb.setDefaultRequestConfig(rcb.build()).build();
}

// get JSONObject from JSON response from google map api in order to get detailed location identification
public JSONObject getLocationInfo(String address) {
    StringBuilder stringBuilder = new StringBuilder();
    try {
        // replace white spaces
        address = address.replaceAll("[ \\u00A0]", "%20");
        // make request to google map api and get response
        HttpPost httppost = new HttpPost("http://maps.google.com/maps/api/geocode/json?address=" + address + "&sensor=false");
        HttpClient client;
        // check for proxy settings
        if (GlobalConstants.PROXY_PORT != 0) {
            HttpHost proxy = new HttpHost(GlobalConstants.PROXY_ADDRESS, GlobalConstants.PROXY_PORT, "http");
            client = HttpClientBuilder.create().setProxy(proxy).build();
        } else {
            client = HttpClientBuilder.create().build();
        }
        HttpResponse response;
        stringBuilder = new StringBuilder();
        // obtaining response
        response = client.execute(httppost);
        HttpEntity entity = response.getEntity();
        InputStream stream = entity.getContent();
        int b;
        while ((b = stream.read()) != -1) {
            stringBuilder.append((char) b);
        }
    } catch (ClientProtocolException e) {
        logger.info("Client Protocol Exception : ", e);
    } catch (IOException e) {
        logger.info("IO Exception : ", e);
    }
    // forming JSON object from response
    JSONObject jsonObject = new JSONObject();
    try {
        jsonObject = new JSONObject(stringBuilder.toString());
    } catch (JSONException e) {
        logger.info("Wrong JSON : " + stringBuilder.toString());
    }
    return jsonObject;
}

private CloseableHttpClient buildClient(Config config) {
    HttpClientBuilder cb = HttpClientBuilder.create().setUserAgent(USER_AGENT);
    if (config.getProxy() != null) {
        try {
            URL url = new URL(config.getProxy().getHost());
            HttpHost proxy = new HttpHost(url.getHost(), config.getProxy().getPort(), url.getProtocol());
            cb.setProxy(proxy);
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    if (config.isIgnoreSSLVerification()) {
        cb.setSslcontext(UntrustedSSL.getSSLContext());
        cb.setHostnameVerifier(new AllowAllHostnameVerifier());
    }
    if (config.getSslContext() != null)
        cb.setSslcontext(config.getSslContext());
    if (config.getMaxConnections() > 0) {
        cb.setMaxConnTotal(config.getMaxConnections());
    }
    if (config.getMaxConnectionsPerRoute() > 0) {
        cb.setMaxConnPerRoute(config.getMaxConnectionsPerRoute());
    }
    RequestConfig.Builder rcb = RequestConfig.custom();
    if (config.getConnectTimeout() > 0)
        rcb.setConnectTimeout(config.getConnectTimeout());
    if (config.getReadTimeout() > 0)
        rcb.setSocketTimeout(config.getReadTimeout());
    if (INTERCEPTOR != null) {
        INTERCEPTOR.onClientCreate(cb, rcb, config);
    }
    return cb.setDefaultRequestConfig(rcb.build()).build();
}

@Provides
protected CloseableHttpClient getHttpClient(PoolingHttpClientConnectionManager connectionManager, RequestConfig requestConfig) {
    HttpClientBuilder httpClientBuilder = HttpClients.custom();
    httpClientBuilder.setUserAgent(USER_AGENT);
    // Request configuration
    httpClientBuilder.setDefaultRequestConfig(requestConfig);
    // Connection pool
    httpClientBuilder.setConnectionManager(connectionManager);
    httpClientBuilder.setConnectionManagerShared(true);
    // Use system default for proxy
    httpClientBuilder.useSystemProperties();
    return httpClientBuilder.build();
}

public InputStream download() {
    HttpClientBuilder clientBuilder = HttpClientBuilder.create().useSystemProperties();
    try {
        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        SSLConnectionSocketFactory ssf = new SSLConnectionSocketFactory(builder.build());
        Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", //$NON-NLS-1$ //$NON-NLS-2$
        ssf).build();
        clientBuilder.setConnectionManager(new BasicHttpClientConnectionManager(r));
    } catch (Exception e) {
        for (DownloadListenerInterface listener : listeners) {
            listener.errorOccured(e);
        }
    }
    HttpClient client = clientBuilder.build();
    InputStream content = null;
    try {
        httpGet = new HttpGet(url);
        HttpResponse response = null;
        if (httpGet.isAborted()) {
            httpGet.abort();
            if (httpGet.isAborted()) {
                return null;
            }
        }
        response = client.execute(httpGet);
        if (httpGet.isAborted()) {
            for (DownloadListenerInterface listener : listeners) {
                listener.aborted(url);
            }
            return null;
        }
        HttpEntity entity = response.getEntity();
        content = entity.getContent();
        for (DownloadListenerInterface listener : listeners) {
            listener.dataReceived(content, url);
        }
    } catch (Exception e) {
        for (DownloadListenerInterface listener : listeners) {
            listener.errorOccured(e);
        }
    }
    return content;
}

@Override
public Boolean call() throws Exception {
    try (CloseableHttpClient client = HttpClientBuilder.create().build()) {
        HttpPost httpPost = new HttpPost(url);
        try {
            StringEntity dataEntity = new StringEntity(data);
            try {
                httpPost.addHeader("X-Pyramus-Signature", signature);
                httpPost.setEntity(dataEntity);
                client.execute(httpPost);
                return true;
            } finally {
                EntityUtils.consume(dataEntity);
            }
        } finally {
            httpPost.releaseConnection();
        }
    } catch (IOException e) {
        logger.log(Level.SEVERE, "Failed to send webhook notification to " + url, e);
    }
    return false;
}

@Override
public void doWork() throws Exception {
    HttpClient httpClient = HttpClientBuilder.create().build();
    HttpRequestBase request = getRequest(requestModel);
    List<RequestHeaderModel> requestModelHeaders = requestModel.getHeaders();
    for (RequestHeaderModel header : requestModelHeaders) {
        request.setHeader(header.getName(), header.getValue());
    }
    // Add the header here so the request is successful.
    if (request.getHeaders(ContentTypeHelper.CONTENT_TYPE_HEADER) == null || request.getHeaders(ContentTypeHelper.CONTENT_TYPE_HEADER).length == 0) {
        RestContentType type = ExampleParser.guessContentType(requestModel.getRequest());
        if (null != type) {
            request.setHeader(ContentTypeHelper.CONTENT_TYPE_HEADER, type.getName());
        }
    }
    // check if content-type is parameterized
    HttpResponse httpResponse = httpClient.execute(request);
    ApiMethodModel methodModel = new ApiMethodModel();
    methodModel.setRequestHeaders(request.getAllHeaders());
    methodModel.setHttpResponse(httpResponse);
    methodModel.setRequestModel(requestModel);
    onSuccess(methodModel);
}

@Override
protected HttpClient createDefaultHttpClient() {
    final HttpClientBuilder builder = HttpClientBuilder.create();
    RequestConfig.Builder requestBuilder = RequestConfig.custom();
    if (defaultProxy != null) {
        requestBuilder.setProxy(defaultProxy);
    }
    builder.disableContentCompression();
    builder.setDefaultRequestConfig(requestBuilder.build());
    return builder.build();
}

private void process() throws ClientProtocolException, IOException {
    HttpClient httpClient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet(NOTICE_URL);
    httpGet.addHeader("X-SCCH", scch);
    HttpResponse response = null;
    response = httpClient.execute(httpGet);
    System.out.println("Notice Response Code : " + response.getStatusLine().getStatusCode());
    String cacheTag = response.getFirstHeader("X-Scouter-ETag").getValue();
    if (StringUtil.isEmpty(cacheTag))
        return;
    File noticeFile = new File(RCPUtil.getWorkingDirectory(), NOTICE_FILENAME);
    if (// first time 
    noticeFile.exists() == false || // changed notice
    cacheTag.equals(new String(FileUtil.readAll(noticeFile), "UTF-8")) == false || // a month ago noticed
    noticeFile.lastModified() < (System.currentTimeMillis() - DateUtil.MILLIS_PER_DAY * 30)) {
        HttpEntity entity = response.getEntity();
        String html = EntityUtils.toString(entity, "UTF-8");
        ExUtil.exec(PlatformUI.getWorkbench().getDisplay(), new Runnable() {

            @Override
            public void run() {
                System.out.println("Open Notice Dialog");
                new NoticeDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), html).open();
            }
        });
        FileUtil.save(noticeFile, cacheTag.getBytes());
    }
}

private void process() throws ClientProtocolException, IOException {
    HttpClient httpClient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet(NOTICE_URL);
    httpGet.addHeader("X-SCCH", scch);
    HttpResponse response = null;
    response = httpClient.execute(httpGet);
    System.out.println("Notice Response Code : " + response.getStatusLine().getStatusCode());
    String cacheTag = response.getFirstHeader("X-Scouter-ETag").getValue();
    if (StringUtil.isEmpty(cacheTag))
        return;
    File noticeFile = new File(RCPUtil.getWorkingDirectory(), NOTICE_FILENAME);
    if (// first time 
    noticeFile.exists() == false || // changed notice
    cacheTag.equals(new String(FileUtil.readAll(noticeFile), "UTF-8")) == false || // a month ago noticed
    noticeFile.lastModified() < (System.currentTimeMillis() - DateUtil.MILLIS_PER_DAY * 30)) {
        HttpEntity entity = response.getEntity();
        String html = EntityUtils.toString(entity, "UTF-8");
        ExUtil.exec(PlatformUI.getWorkbench().getDisplay(), new Runnable() {

            @Override
            public void run() {
                System.out.println("Open Notice Dialog");
                new NoticeDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), html).open();
            }
        });
        FileUtil.save(noticeFile, cacheTag.getBytes());
    }
}

/**
     * Attempt to get the value for the AWSUniqueId dimension used in SignalFx AWS integrations.
     *
     * @param timeoutInMs
     *            how long to wait in milliseconds for AWS to respond
     * @return null if the value was not obtained for any reason
     */
public static String get(int timeoutInMs) {
    RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(timeoutInMs).build();
    HttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).build();
    HttpGet request = new HttpGet(URL);
    try {
        HttpResponse response = client.execute(request);
        JsonNode object = MAPPER.readTree(response.getEntity().getContent());
        return object.get(INSTANCE_ID).asText() + "_" + object.get(REGION).asText() + "_" + object.get(ACCOUNT_ID).asText();
    } catch (Exception e) {
        log.trace("Exception trying to execute {}, Exception: {} ", request, e);
    }
    return null;
}

public static String getFromHttp(URL url, String user, String password) throws IOException {
    HttpClientContext context = HttpClientContext.create();
    if (user != null) {
        HttpHost targetHost = new HttpHost(url.getHost(), url.getPort(), url.getProtocol());
        AuthCache authCache = new BasicAuthCache();
        authCache.put(targetHost, new BasicScheme());
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(user, password));
        context.setCredentialsProvider(credentialsProvider);
        context.setAuthCache(authCache);
    }
    HttpClient client = HttpClientBuilder.create().build();
    HttpGet request = new HttpGet(url.toExternalForm());
    HttpResponse response = client.execute(request, context);
    InputStreamReader streamReader = new InputStreamReader(response.getEntity().getContent());
    String data = CharStreams.toString(streamReader);
    streamReader.close();
    return data;
}

public Hc4Client build() {
    final Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", SSLConnectionSocketFactory.getSystemSocketFactory()).build();
    final PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
    cm.setMaxTotal(200);
    cm.setDefaultMaxPerRoute(parameters.getMaximumTrackCount());
    final HttpClientBuilder httpClientBuilder = HttpClientBuilder.create().setConnectionManager(cm).setUserAgent("Zapper/1.0-HC4");
    if (proxyServer != null) {
        httpClientBuilder.setProxy(proxyServer);
    }
    if (credentialsProvider != null) {
        httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    }
    return new Hc4Client(parameters, remoteUrl, httpClientBuilder.build(), preemptiveAuth ? credentialsProvider : null);
}

private void checkServerRunning() {
    try (CloseableHttpClient client = HttpClientBuilder.create().build()) {
        CloseableHttpResponse response = client.execute(new HttpGet(baseUrl + PING_PATH));
        if (response != null && response.getStatusLine() != null) {
            Assume.assumeThat(response.getStatusLine().getStatusCode(), Is.is(200));
        }
    } catch (IOException e) {
        throw new AssumptionViolatedException("SolrServer does not seem to be running", e);
    }
}

@Bean(name = YarnSystemConstants.DEFAULT_ID_RESTTEMPLATE)
public RestTemplate restTemplate() {
    HttpClientBuilder builder = HttpClientBuilder.create();
    UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(securityProperties.getUser().getName(), securityProperties.getUser().getPassword());
    BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(new AuthScope(null, -1, null), credentials);
    builder.setDefaultCredentialsProvider(credentialsProvider);
    HttpClient httpClient = builder.build();
    return new RestTemplate(new HttpComponentsClientHttpRequestFactory(httpClient));
}

private CloseableHttpClient initHttpClient() {
    RequestConfig requestConfig = getRequestConfig();
    String serverVersion = ServerVersionHolder.getVersion().getDisplayVersion();
    connectionManager = new PoolingHttpClientConnectionManager();
    return HttpClientBuilder.create().useSystemProperties().addInterceptorFirst(new RequestAcceptEncoding()).addInterceptorFirst(new ResponseContentEncoding()).setRetryHandler(new DefaultHttpRequestRetryHandler(RETRY_COUNT, true)).setConnectionManager(connectionManager).setDefaultRequestConfig(requestConfig).setUserAgent("JetBrains TeamCity " + serverVersion).build();
}

public Document get(String path) {
    Document document = null;
    InputStream result = null;
    path = trimSlashes(path);
    String fullPath = url + '/' + path;
    HttpGet httpGet = new HttpGet(fullPath);
    try {
        HttpClient httpClient = HttpClientBuilder.create().build();
        HttpResponse getResponse = httpClient.execute(httpGet);
        //do not close this httpClient
        result = getResponse.getEntity().getContent();
        document = XMLUtils.convertStreamToXML(result);
    } catch (Exception e) {
        getGotError(e, fullPath);
    }
    return document;
}

@SuppressWarnings("unchecked")
public static Map<String, String> requestJson(HttpRequestBase request) throws Exception {
    //创建HttpClientBuilder  
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    //HttpClient  
    CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
    HttpResponse httpResponse = closeableHttpClient.execute(request);
    //获��应消�实体  
    HttpEntity entity = httpResponse.getEntity();
    //判断�应实体是�为空  
    Map<String, String> map = new HashMap<String, String>();
    if (entity != null) {
        map = new ObjectMapper().readValue(EntityUtils.toString(entity), Map.class);
    }
    closeableHttpClient.close();
    return map;
}

/**
	 * Pulls a page and attempts to discover a feed for it via
	 * link[rel='alternate'].
	 * 
	 * @param url
	 *            The URL of the page to try and discover the feed for.
	 * @return The feedsource if matched or created, may be null.
	 * @throws ClientProtocolException
	 *             If the page could not be pulled.
	 * @throws IOException
	 *             If the page could not be pulled.
	 * @throws DataOperationException
	 *             If a query could not be executed.
	 */
public FeedSource discover(final String url) throws ClientProtocolException, IOException, DataOperationException {
    log.fine("Discovering feed for " + url);
    try (final CloseableHttpClient client = HttpClientBuilder.create().build()) {
        final HttpGet get = new HttpGet(url);
        try (final CloseableHttpResponse response = client.execute(get)) {
            final String html = EntityUtils.toString(response.getEntity());
            final Document doc = Jsoup.parse(html);
            final Elements alternateLinks = doc.select("link");
            for (final Element alternateLink : alternateLinks) {
                if ("alternate".equals(alternateLink.attr("rel"))) {
                    if ("application/rss+xml".equals(alternateLink.attr("type"))) {
                        log.fine("Found rss link " + alternateLink.attr("href"));
                        final String rss = alternateLink.attr("href");
                        return this.feedSourceManager.findOrCreateByFeedUrl(rss);
                    }
                    log.fine("Found alternate link " + alternateLink.html());
                } else {
                    log.fine("Found link " + alternateLink.html());
                }
            }
        }
    }
    return null;
}

@Override
public Boolean apply(Void input) {
    if (mWebServer == null || !mWebServer.getServer().isRunning()) {
        return false;
    }
    HttpClient client = HttpClientBuilder.create().build();
    HttpPost method = new HttpPost(String.format("http://%s:%d%s/%s///%s", mWebServer.getBindHost(), mWebServer.getLocalPort(), Constants.REST_API_PREFIX, PathsRestServiceHandler.SERVICE_PREFIX, PathsRestServiceHandler.EXISTS));
    try {
        HttpResponse response = client.execute(method);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            return true;
        }
        LOG.debug(IOUtils.toString(response.getEntity().getContent()));
        return false;
    } catch (IOException e) {
        LOG.debug("Exception: ", e);
        return false;
    }
}

@Override
protected TTransport newTransport(String uri, HttpHeaders headers) throws TTransportException {
    final SSLContext sslContext;
    try {
        sslContext = SSLContextBuilder.create().loadTrustMaterial((TrustStrategy) ( chain,  authType) -> true).build();
    } catch (GeneralSecurityException e) {
        throw new TTransportException("failed to initialize an SSL context", e);
    }
    final THttpClient client = new THttpClient(uri, HttpClientBuilder.create().setSSLContext(sslContext).build());
    client.setCustomHeaders(headers.names().stream().collect(toImmutableMap(AsciiString::toString,  name -> String.join(", ", headers.getAll(name)))));
    return client;
}

private Long retrieveLastUpdateDate(ArtifactVersionBean artifactVersionBean) {
    CloseableHttpClient client = null;
    try {
        client = HttpClientBuilder.create().setUserAgent(configurer.getUserAgent()).build();
        String url = String.format(configurer.getArtifactVersionRepositoryPomUrl(), artifactVersionBean.getGroupId().replace(".", "/"), artifactVersionBean.getArtifactId(), artifactVersionBean.getVersion());
        HttpHead httpHead = new HttpHead(url);
        httpHead.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE);
        // The possible errors here are considered as secondary and will not be seen by the user
        // We may want to reconsider it
        HttpResponse response = client.execute(httpHead);
        Header lastUpdateDate = response.getFirstHeader(LAST_MODIFIED_HEADER);
        if (lastUpdateDate != null) {
            return DateUtil.parseDate(lastUpdateDate.getValue()).getTime();
        }
        LOGGER.error("An error occurred while retrieving the last update date for " + artifactVersionBean.getId());
    } catch (Exception e) {
        LOGGER.error("An error occurred while retrieving the last update date for " + artifactVersionBean.getId(), e);
    } finally {
        if (client != null) {
            try {
                client.close();
            } catch (IOException e) {
                LOGGER.error("Unable to close the HTTP client", e);
            }
        }
    }
    return null;
}

@Override
public ConnectionManagerAwareHttpClient create(HttpClientSettings settings) {
    final HttpClientBuilder builder = HttpClients.custom();
    // Note that it is important we register the original connection manager with the
    // IdleConnectionReaper as it's required for the successful deregistration of managers
    // from the reaper. See https://github.com/aws/aws-sdk-java/issues/722.
    final HttpClientConnectionManager cm = cmFactory.create(settings);
    builder.setRequestExecutor(new SdkHttpRequestExecutor()).setKeepAliveStrategy(buildKeepAliveStrategy(settings)).disableRedirectHandling().disableAutomaticRetries().setConnectionManager(ClientConnectionManagerFactory.wrap(cm));
    //
    if (!(settings.useGzip())) {
        builder.disableContentCompression();
    }
    HttpResponseInterceptor itcp = new CRC32ChecksumResponseInterceptor();
    if (settings.calculateCRC32FromCompressedData()) {
        builder.addInterceptorFirst(itcp);
    } else {
        builder.addInterceptorLast(itcp);
    }
    addProxyConfig(builder, settings);
    final ConnectionManagerAwareHttpClient httpClient = new SdkHttpClient(builder.build(), cm);
    if (settings.useReaper()) {
        IdleConnectionReaper.registerConnectionManager(cm, settings.getMaxIdleConnectionTime());
    }
    return httpClient;
}