예제 #1
1
  private HttpClient getClient() {
    if (client == null) {
      HttpClientBuilder clientBuilder = HttpClients.custom();
      RequestConfig.Builder configBuilder = RequestConfig.custom();
      if (proxy != null && !Proxy.NO_PROXY.equals(proxy)) {
        isUsingProxy = true;
        InetSocketAddress adr = (InetSocketAddress) proxy.address();
        clientBuilder.setProxy(new HttpHost(adr.getHostName(), adr.getPort()));
      }
      if (timeout != null) {
        configBuilder.setConnectTimeout(timeout.intValue());
      }
      if (readTimeout != null) {
        configBuilder.setSocketTimeout(readTimeout.intValue());
      }
      if (followRedirects != null) {
        configBuilder.setRedirectsEnabled(followRedirects.booleanValue());
      }
      if (hostnameverifier != null) {
        SSLConnectionSocketFactory sslConnectionFactory =
            new SSLConnectionSocketFactory(getSSLContext(), hostnameverifier);
        clientBuilder.setSSLSocketFactory(sslConnectionFactory);
        Registry<ConnectionSocketFactory> registry =
            RegistryBuilder.<ConnectionSocketFactory>create()
                .register("https", sslConnectionFactory)
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .build();
        clientBuilder.setConnectionManager(new BasicHttpClientConnectionManager(registry));
      }
      clientBuilder.setDefaultRequestConfig(configBuilder.build());
      client = clientBuilder.build();
    }

    return client;
  }
예제 #2
0
 /**
  * Called primarily from HTTPMethod to do the bulk of the execution. Assumes HTTPMethod has
  * inserted its headers into request.
  *
  * @param method
  * @param methoduri
  * @param rb
  * @return Request+Response pair
  * @throws HTTPException
  */
 ExecState execute(HTTPMethod method, URI methoduri, RequestBuilder rb) throws HTTPException {
   this.execution = new ExecState();
   this.requestURI = methoduri;
   AuthScope methodscope = HTTPAuthUtil.uriToAuthScope(methoduri);
   AuthScope target = HTTPAuthUtil.authscopeUpgrade(this.scope, methodscope);
   synchronized (this) { // keep coverity happy
     // Merge Settings;
     Settings merged = HTTPUtil.merge(globalsettings, localsettings);
     if (!this.cachevalid) {
       RequestConfig.Builder rcb = RequestConfig.custom();
       this.cachedconfig = configureRequest(rcb, merged);
       HttpClientBuilder cb = HttpClients.custom();
       configClient(cb, merged);
       setAuthenticationAndProxy(cb);
       this.cachedclient = cb.build();
       rb.setConfig(this.cachedconfig);
       this.cachevalid = true;
     }
   }
   this.execution.request = (HttpRequestBase) rb.build();
   try {
     HttpHost targethost = HTTPAuthUtil.authscopeToHost(target);
     this.execution.response =
         cachedclient.execute(targethost, this.execution.request, this.sessioncontext);
   } catch (IOException ioe) {
     throw new HTTPException(ioe);
   }
   return this.execution;
 }
 /** Executes the request against the appliance API (Should not be called directly). */
 @Override
 public MuteCheckResponse executeRequest() throws MorpheusApiRequestException {
   CloseableHttpClient client = null;
   try {
     URIBuilder uriBuilder = new URIBuilder(endpointUrl);
     uriBuilder.setPath("/api/monitoring/checks/" + this.getCheckId() + "/quarantine");
     HttpPut request = new HttpPut(uriBuilder.build());
     this.applyHeaders(request);
     HttpClientBuilder clientBuilder = HttpClients.custom();
     clientBuilder.setDefaultRequestConfig(this.getRequestConfig());
     client = clientBuilder.build();
     request.addHeader("Content-Type", "application/json");
     request.setEntity(new StringEntity(generateRequestBody()));
     CloseableHttpResponse response = client.execute(request);
     return MuteCheckResponse.createFromStream(response.getEntity().getContent());
   } catch (Exception ex) {
     // Throw custom exception
     throw new MorpheusApiRequestException(
         "Error Performing API Request for muting/unmuting a Check", ex);
   } finally {
     if (client != null) {
       try {
         client.close();
       } catch (IOException io) {
         // ignore
       }
     }
   }
 }
예제 #4
0
  public static String shortIt(String longUrl) {
    if (!longUrl.startsWith("http")) {
      longUrl = "http://" + longUrl;
    }
    CloseableHttpClient httpclient = HttpClients.custom().build(); // 可以帮助记录cookie
    String result = longUrl;
    String uri = "http://vwz.me/API.php?url=" + longUrl + "&callback=json";
    HttpGet get = new HttpGet(uri);
    try {
      CloseableHttpResponse execute = httpclient.execute(get);
      int statusCode = execute.getStatusLine().getStatusCode();
      switch (statusCode) {
        case 200:
          String html = IOUtils.toString(execute.getEntity().getContent(), "UTF-8");
          String json = html.substring(5, html.length() - 2);
          logger.info("json : {}", json);
          result = parseMsg(json);
          break;
        default:
          break;
      }

    } catch (IOException e) {
      e.printStackTrace();
    }
    try {
      httpclient.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    logger.info("short {} to {}", longUrl, result);
    return result;
  }
  private static CloseableHttpClient createHTTPClient(
      PrivateKey privateKey, X509Certificate certificate, boolean validateCertificate) {
    // HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    HttpClientBuilder clientBuilder = HttpClients.custom();
    try {
      SSLContext sslContext =
          TrustUtils.getCustomSSLContext(privateKey, certificate, validateCertificate);
      clientBuilder.setSslcontext(sslContext);
    } catch (KeyStoreException
        | NoSuchAlgorithmException
        | CertificateException
        | IOException
        | KeyManagementException
        | UnrecoverableKeyException
        | NoSuchProviderException ex) {
      LOGGER.log(Level.WARNING, "unable to set SSL context", ex);
      return null;
    }

    RequestConfig.Builder rcBuilder = RequestConfig.custom();
    // handle redirects :)
    rcBuilder.setRedirectsEnabled(true);
    // HttpClient bug caused by Lighttpd
    rcBuilder.setExpectContinueEnabled(false);
    clientBuilder.setDefaultRequestConfig(rcBuilder.build());

    // create connection manager
    // ClientConnectionManager connMgr = new SingleClientConnManager(params, registry);

    // return new DefaultHttpClient(connMgr, params);
    return clientBuilder.build();
  }
예제 #6
0
  /**
   * Tests that if a socket fails to connect, the allocated connection is properly released back to
   * the connection manager.
   */
  @Test
  public void testSocketConnectFailureReleasesConnection() throws Exception {
    final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class);
    final ConnectionRequest connrequest = Mockito.mock(ConnectionRequest.class);
    Mockito.when(connrequest.get(Mockito.anyInt(), Mockito.any(TimeUnit.class))).thenReturn(conn);
    final HttpClientConnectionManager connmgr = Mockito.mock(HttpClientConnectionManager.class);
    Mockito.doThrow(new ConnectException())
        .when(connmgr)
        .connect(
            Mockito.any(HttpClientConnection.class),
            Mockito.any(HttpRoute.class),
            Mockito.anyInt(),
            Mockito.any(HttpContext.class));

    Mockito.when(connmgr.requestConnection(Mockito.any(HttpRoute.class), Mockito.any()))
        .thenReturn(connrequest);

    final HttpClient client = HttpClients.custom().setConnectionManager(connmgr).build();
    final HttpContext context = new BasicHttpContext();
    final HttpGet httpget = new HttpGet("http://www.example.com/a");

    try {
      client.execute(httpget, context);
      Assert.fail("expected IOException");
    } catch (final IOException expected) {
    }

    Mockito.verify(connmgr).releaseConnection(conn, null, 0, TimeUnit.MILLISECONDS);
  }
 private HttpClient createHttpClient() {
   if (Boolean.parseBoolean(System.getProperty("proxySet"))) {
     HttpHost httpHost =
         new HttpHost(
             System.getProperty("http.proxyHost"),
             Integer.parseInt(System.getProperty("http.proxyPort")));
     DefaultProxyRoutePlanner defaultProxyRoutePlanner = new DefaultProxyRoutePlanner(httpHost);
     return HttpClients.custom().setRoutePlanner(defaultProxyRoutePlanner).build();
     //            todo - need to support SOCKS protocol for this solution to work - jamesdbloom
     // 12/01/2014
     //            return HttpClients.custom().setRoutePlanner(new
     // SystemDefaultRoutePlanner(ProxySelector.getDefault())).build();
   } else {
     return HttpClients.custom().build();
   }
 }
  @Test
  public void testTracingFalse()
      throws ClientProtocolException, IOException, UnsatisfiedExpectationException {
    when(clientTracer.startNewSpan(PATH)).thenReturn(null);

    final HttpRequestImpl request = new HttpRequestImpl();
    request
        .method(Method.GET)
        .path(PATH)
        .httpMessageHeader(BraveHttpHeaders.Sampled.getName(), "false");
    final HttpResponseImpl response = new HttpResponseImpl(200, null, null);
    responseProvider.set(request, response);

    final CloseableHttpClient httpclient =
        HttpClients.custom()
            .addInterceptorFirst(new BraveHttpRequestInterceptor(clientTracer))
            .addInterceptorFirst(new BraveHttpResponseInterceptor(clientTracer))
            .build();
    try {
      final HttpGet httpGet = new HttpGet(REQUEST);
      final CloseableHttpResponse httpClientResponse = httpclient.execute(httpGet);
      assertEquals(200, httpClientResponse.getStatusLine().getStatusCode());
      httpClientResponse.close();
      mockServer.verify();

      final InOrder inOrder = inOrder(clientTracer);
      inOrder.verify(clientTracer).startNewSpan(PATH);
      inOrder.verify(clientTracer).submitBinaryAnnotation("request", "GET " + PATH);
      inOrder.verify(clientTracer).setClientSent();
      inOrder.verify(clientTracer).setClientReceived();
      verifyNoMoreInteractions(clientTracer);
    } finally {
      httpclient.close();
    }
  }
예제 #9
0
파일: HttpUtil.java 프로젝트: sumekey/sms
 public static CloseableHttpClient createSSLClientDefault() {
   try {
     SSLContext sslContext =
         new SSLContextBuilder()
             .loadTrustMaterial(
                 null,
                 new TrustStrategy() {
                   // 信任所有
                   public boolean isTrusted(X509Certificate[] chain, String authType)
                       throws CertificateException {
                     return true;
                   }
                 })
             .build();
     SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
     return HttpClients.custom().setSSLSocketFactory(sslsf).build();
   } catch (KeyManagementException e) {
     e.printStackTrace();
   } catch (NoSuchAlgorithmException e) {
     e.printStackTrace();
   } catch (KeyStoreException e) {
     e.printStackTrace();
   }
   return HttpClients.createDefault();
 }
예제 #10
0
  private CloseableHttpClient generateClient(Site site) {
    HttpClientBuilder httpClientBuilder =
        HttpClients.custom().setConnectionManager(connectionManager);
    if (site != null && site.getUserAgent() != null) {
      httpClientBuilder.setUserAgent(site.getUserAgent());
    } else {
      httpClientBuilder.setUserAgent("");
    }
    if (site == null || site.isUseGzip()) {
      httpClientBuilder.addInterceptorFirst(
          new HttpRequestInterceptor() {

            public void process(final HttpRequest request, final HttpContext context)
                throws HttpException, IOException {
              if (!request.containsHeader("Accept-Encoding")) {
                request.addHeader("Accept-Encoding", "gzip");
              }
            }
          });
    }
    SocketConfig socketConfig =
        SocketConfig.custom().setSoKeepAlive(true).setTcpNoDelay(true).build();
    httpClientBuilder.setDefaultSocketConfig(socketConfig);
    if (site != null) {
      httpClientBuilder.setRetryHandler(
          new DefaultHttpRequestRetryHandler(site.getRetryTimes(), true));
    }
    generateCookie(httpClientBuilder, site);
    return httpClientBuilder.build();
  }
  protected CloseableHttpClient newClient() {
    final RequestConfig requestConfig =
        RequestConfig.custom()
            .setSocketTimeout(SOCKET_TIMEOUT.get())
            .setConnectTimeout(CONNECTION_TIMEOUT.get())
            .setCookieSpec(CookieSpecs.IGNORE_COOKIES)
            .build();

    return HttpClients.custom()
        .setConnectionManager(newConnectionManager())
        .setDefaultRequestConfig(requestConfig)
        .setRetryHandler(new DefaultHttpRequestRetryHandler(0, false))
        .setRedirectStrategy(
            new RedirectStrategy() {
              @Override
              public boolean isRedirected(
                  HttpRequest request, HttpResponse response, HttpContext context)
                  throws ProtocolException {
                return false;
              }

              @Override
              public HttpUriRequest getRedirect(
                  HttpRequest request, HttpResponse response, HttpContext context)
                  throws ProtocolException {
                return null;
              }
            })
        .build();
  }
  public void afterPropertiesSet() {
    HttpClientBuilder httpClientBuilder = HttpClients.custom();

    httpClientBuilder.setConnectionManager(getPoolingHttpClientConnectionManager());

    if ((_login != null) && (_password != null)) {
      CredentialsProvider credentialsProvider = new BasicCredentialsProvider();

      credentialsProvider.setCredentials(
          new AuthScope(_hostName, _hostPort), new UsernamePasswordCredentials(_login, _password));

      httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
      httpClientBuilder.setRetryHandler(new HttpRequestRetryHandlerImpl());
    } else {
      if (_logger.isWarnEnabled()) {
        _logger.warn("Login and password are required");
      }
    }

    try {
      setProxyHost(httpClientBuilder);

      _closeableHttpClient = httpClientBuilder.build();

      if (_logger.isDebugEnabled()) {
        _logger.debug("Configured client for " + _protocol + "://" + _hostName);
      }
    } catch (Exception e) {
      _logger.error("Unable to configure client", e);
    }
  }
예제 #13
0
  protected CloseableHttpClient constructHttpClient() throws IOException {
    RequestConfig config =
        RequestConfig.custom()
            .setConnectTimeout(20 * 1000)
            .setConnectionRequestTimeout(20 * 1000)
            .setSocketTimeout(20 * 1000)
            .setMaxRedirects(20)
            .build();

    URL mmsc = new URL(apn.getMmsc());
    CredentialsProvider credsProvider = new BasicCredentialsProvider();

    if (apn.hasAuthentication()) {
      credsProvider.setCredentials(
          new AuthScope(
              mmsc.getHost(), mmsc.getPort() > -1 ? mmsc.getPort() : mmsc.getDefaultPort()),
          new UsernamePasswordCredentials(apn.getUsername(), apn.getPassword()));
    }

    return HttpClients.custom()
        .setConnectionReuseStrategy(new NoConnectionReuseStrategyHC4())
        .setRedirectStrategy(new LaxRedirectStrategy())
        .setUserAgent("Android-Mms/2.0")
        .setConnectionManager(new BasicHttpClientConnectionManager())
        .setDefaultRequestConfig(config)
        .setDefaultCredentialsProvider(credsProvider)
        .build();
  }
예제 #14
0
  @RequestMapping(value = "/kkn1234/create", method = RequestMethod.POST)
  public String formSubmit(@ModelAttribute User user, Model model)
      throws MalformedURLException, IOException {
    model.addAttribute("user", user);
    HttpPost post =
        new HttpPost(
            "http://ec2-52-4-138-196.compute-1.amazonaws.com/magento/index.php/customer/account/createpost/");
    BasicCookieStore cookieStore = new BasicCookieStore();
    CloseableHttpClient httpclient =
        HttpClients.custom().setDefaultCookieStore(cookieStore).build();
    List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
    nameValuePairs.add(new BasicNameValuePair("firstname", user.getFirstName()));
    nameValuePairs.add(new BasicNameValuePair("lastname", user.getLastName()));
    nameValuePairs.add(new BasicNameValuePair("email", user.getEmail()));
    nameValuePairs.add(new BasicNameValuePair("password", user.getPassword()));
    nameValuePairs.add(new BasicNameValuePair("confirmation", user.getConfirmation()));

    post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
    HttpResponse response = httpclient.execute(post);
    response = httpclient.execute(post);
    System.out.println("Status code is " + response.getStatusLine().getStatusCode());
    System.out.println(response.toString());
    System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++");
    System.out.println(response.getFirstHeader("Location"));
    HttpEntity entity = response.getEntity();
    EntityUtils.consume(entity);
    EntityUtils.consume(response.getEntity());

    /*File newTextFile = new File("C:\\Users\\Kris\\Desktop\\temp.html");
    FileWriter fileWriter = new FileWriter(newTextFile);
    fileWriter.write(response.toString());
    fileWriter.close();*/
    return "result";
  }
  public static void main(String[] args) throws Exception {
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
        new AuthScope("localhost", 443), new UsernamePasswordCredentials("username", "password"));
    CloseableHttpClient httpclient =
        HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
    try {
      HttpGet httpget = new HttpGet("https://localhost/protected");

      System.out.println("executing request" + httpget.getRequestLine());
      CloseableHttpResponse response = httpclient.execute(httpget);
      try {
        HttpEntity entity = response.getEntity();

        System.out.println("----------------------------------------");
        System.out.println(response.getStatusLine());
        if (entity != null) {
          System.out.println("Response content length: " + entity.getContentLength());
        }
        EntityUtils.consume(entity);
      } finally {
        response.close();
      }
    } finally {
      httpclient.close();
    }
  }
예제 #16
0
 @Test
 public final void givenDeprecatedApi_whenRequestHasCustomUserAgent_thenCorrect()
     throws ClientProtocolException, IOException {
   instance = HttpClients.custom().build();
   final HttpGet request = new HttpGet(SAMPLE_URL);
   request.setHeader(HttpHeaders.USER_AGENT, "Mozilla/5.0 Firefox/26.0");
   response = instance.execute(request);
 }
예제 #17
0
  @Test
  public void example3() {
    CookieStore cookieStore = new BasicCookieStore();
    BasicClientCookie cookie = new BasicClientCookie("name", "value");
    cookieStore.addCookie(cookie);

    CloseableHttpClient httpClient =
        HttpClients.custom().setDefaultCookieStore(cookieStore).build();
  }
예제 #18
0
  private static HttpClient createHttpClient() {
    RequestConfig config =
        RequestConfig.custom().setSocketTimeout(TIMEOUT).setConnectTimeout(TIMEOUT).build();

    HttpClientBuilder hcBuilder = HttpClients.custom();
    hcBuilder.setDefaultRequestConfig(config);

    return hcBuilder.build();
  }
 /**
  * Sets the timeouts of the HTTP client.
  *
  * @param connectionTimeout timeout until connection established in milliseconds. Zero means no
  *     timeout.
  * @param socketTimeout timeout for waiting for data in milliseconds. Zero means no timeout.
  * @param maxRequests maximum number of connections to a particuar host
  */
 public static void setParams(int connectionTimeout, int socketTimeout, int maxRequests) {
   PrudentHttpEntityResolver.maxRequests = maxRequests;
   PoolingHttpClientConnectionManager phcConnMgr;
   Registry<ConnectionSocketFactory> registry = //
       RegistryBuilder.<ConnectionSocketFactory>create() //
           .register("http", PlainConnectionSocketFactory.getSocketFactory()) //
           .register("https", SSLConnectionSocketFactory.getSocketFactory()) //
           .build();
   HttpClientBuilder builder = HttpClients.custom();
   builder.setRedirectStrategy(new LaxRedirectStrategy());
   builder.setMaxConnPerRoute(maxRequests);
   builder.setMaxConnTotal(200);
   if ("true".equals(System.getProperty("nu.validator.xml.promiscuous-ssl", "false"))) { //
     try {
       SSLContext promiscuousSSLContext =
           new SSLContextBuilder() //
               .loadTrustMaterial(
                   null,
                   new TrustStrategy() {
                     @Override
                     public boolean isTrusted(X509Certificate[] arg0, String arg1)
                         throws CertificateException {
                       return true;
                     }
                   })
               .build();
       builder.setSslcontext(promiscuousSSLContext);
       HostnameVerifier verifier = //
           SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
       SSLConnectionSocketFactory promiscuousSSLConnSocketFactory = //
           new SSLConnectionSocketFactory(promiscuousSSLContext, verifier);
       registry =
           RegistryBuilder.<ConnectionSocketFactory>create() //
               .register("https", promiscuousSSLConnSocketFactory) //
               .register("http", PlainConnectionSocketFactory.getSocketFactory()) //
               .build();
     } catch (KeyManagementException
         | KeyStoreException
         | NoSuchAlgorithmException
         | NumberFormatException e) {
       e.printStackTrace();
     }
   }
   phcConnMgr = new PoolingHttpClientConnectionManager(registry);
   phcConnMgr.setDefaultMaxPerRoute(maxRequests);
   phcConnMgr.setMaxTotal(200);
   builder.setConnectionManager(phcConnMgr);
   RequestConfig.Builder config = RequestConfig.custom();
   config.setCircularRedirectsAllowed(true);
   config.setMaxRedirects(20); // Gecko default
   config.setConnectTimeout(connectionTimeout);
   config.setCookieSpec(CookieSpecs.BEST_MATCH);
   config.setSocketTimeout(socketTimeout);
   client = builder.setDefaultRequestConfig(config.build()).build();
 }
예제 #20
0
  public static String wechatPost(String url, String params, InputStream keyStream)
      throws Exception {

    KeyStore keyStore = KeyStore.getInstance("PKCS12");
    try {
      keyStore.load(keyStream, WeixinConfig.MCH_ID.toCharArray());
    } finally {
      keyStream.close();
    }

    // Trust own CA and all self-signed certs
    SSLContext sslcontext =
        SSLContexts.custom().loadKeyMaterial(keyStore, WeixinConfig.MCH_ID.toCharArray()).build();
    // Allow TLSv1 protocol only
    SSLConnectionSocketFactory sslsf =
        new SSLConnectionSocketFactory(
            sslcontext,
            new String[] {"TLSv1"},
            null,
            SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
    CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
    try {
      String resp = "";

      HttpPost httpPost = new HttpPost(url);
      StringEntity ent = new StringEntity(params, "utf-8");
      ent.setContentType("application/x-www-form-urlencoded");
      httpPost.setEntity(ent);

      CloseableHttpResponse response = httpclient.execute(httpPost);
      try {
        HttpEntity entity = response.getEntity();

        if (entity != null) {
          System.out.println("Response content length: " + entity.getContentLength());
          BufferedReader bufferedReader =
              new BufferedReader(new InputStreamReader(entity.getContent()));
          String text;
          while ((text = bufferedReader.readLine()) != null) {
            resp += text;
          }
        }
        EntityUtils.consume(entity);
        return resp;
      } catch (Exception e) {
      } finally {
        response.close();
      }
    } finally {
      httpclient.close();
    }

    return null;
  }
예제 #21
0
  @Test
  public void example2() {
    RequestConfig globalConfig =
        RequestConfig.custom().setCookieSpec(CookieSpecs.BEST_MATCH).build();
    CloseableHttpClient httpClient =
        HttpClients.custom().setDefaultRequestConfig(globalConfig).build();

    RequestConfig localConfig =
        RequestConfig.copy(globalConfig).setCookieSpec(CookieSpecs.DEFAULT).build();
    HttpGet httpGet = new HttpGet("http://baidu.com");
    httpGet.setConfig(localConfig);
  }
예제 #22
0
  // 获得设置代理的httpClent实例
  private CloseableHttpClient getHttpClientWithProxy(HttpProxy proxy) {
    HttpHost proxyHost = new HttpHost(proxy.getHost(), proxy.getPort());
    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(
        new AuthScope(proxy.getHost(), proxy.getPort()),
        new UsernamePasswordCredentials(proxy.getUser(), proxy.getPassword()));

    return HttpClients.custom()
        .setProxy(proxyHost)
        .setDefaultCredentialsProvider(credentialsProvider)
        .build();
  }
예제 #23
0
  public static HttpClient createUnsafeClient() {
    try {
      SSLContextBuilder builder = new SSLContextBuilder();
      builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
      SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
      CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();

      return httpclient;
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  @Before
  public void init() throws Exception {
    httpServer = new HttpAPIServer(holder).start();
    httpServerUrl = String.format("http://localhost:%s/", httpPort);

    // this http client doesn't close HTTP connection.
    httpclient =
        HttpClients.custom()
            .setConnectionReuseStrategy((response, context) -> true)
            .setKeepAliveStrategy((response, context) -> 10000000)
            .build();
  }
예제 #25
0
 static {
   HttpClientBuilder custom = HttpClients.custom();
   custom.setUserAgent("Mozilla/5.0 (Windows NT 6.1; rv:25.0) Gecko/20100101 Firefox/25.0");
   RequestConfig config =
       RequestConfig.custom()
           .setConnectionRequestTimeout(5 * 1000)
           .setSocketTimeout(30 * 1000)
           .setConnectTimeout(5 * 1000)
           .build();
   custom.setDefaultRequestConfig(config);
   httpclient = custom.build();
   minHttpclient = HttpClients.createMinimal();
 }
 /**
  * Return a http client instance
  *
  * @param protocol- service endpoint protocol http/https
  * @return
  */
 public static HttpClient getHttpClient(int port, String protocol)
     throws IOException, KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
   HttpClient httpclient;
   if (HTTPS_PROTOCOL.equals(protocol)) {
     SSLContextBuilder builder = new SSLContextBuilder();
     builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
     SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
     httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
   } else {
     httpclient = HttpClients.createDefault();
   }
   return httpclient;
 }
예제 #27
0
 /** Gets an http client to perform requests. */
 public CloseableHttpClient getHttpClient() {
   CloseableHttpClient result;
   try {
     final SSLContextBuilder builder = new SSLContextBuilder();
     if (trustAllMode) builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
     final SSLConnectionSocketFactory sslsf =
         new SSLConnectionSocketFactory(builder.build()) {
           /*
           This is patched to avoid "Could not generate DH keypair" error with JDK < 1.8
           */
           protected void prepareSocket(SSLSocket socket) throws IOException {
             final String[] enabledCipherSuites = socket.getEnabledCipherSuites();
             final String version = System.getProperty("java.version");
             final List<String> list = new ArrayList<String>(Arrays.asList(enabledCipherSuites));
             if (!version.startsWith("1.8")) {
               list.remove("TLS_DHE_RSA_WITH_AES_128_CBC_SHA");
               list.remove("SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA");
               list.remove("TLS_DHE_RSA_WITH_AES_256_CBC_SHA");
             }
             socket.setEnabledCipherSuites(list.toArray(new String[list.size()]));
           }
         };
     result =
         HttpClients.custom()
             .setSSLSocketFactory(sslsf)
             .setRedirectStrategy(new LaxRedirectStrategy())
             .useSystemProperties()
             .build();
   } catch (Exception e) {
     LOG.warning("Could not create custom http client, using default: " + e.getMessage());
     result =
         HttpClients.custom()
             .setRedirectStrategy(new LaxRedirectStrategy())
             .useSystemProperties()
             .build();
   }
   return result;
 }
예제 #28
0
  @Override
  public CloseableHttpClient createClient() {

    SSLConnectionSocketFactory sslsf = buildSSLSocket();
    RequestConfig requestConfig = buildConfig();

    httpClient =
        HttpClients.custom()
            .setSSLSocketFactory(sslsf)
            .setDefaultRequestConfig(requestConfig)
            .build();

    return httpClient;
  }
 protected final void testBasicSslWithKeyStore(String keyStore) throws Exception {
   AbstractEmbeddedServletContainerFactory factory = getFactory();
   addTestTxtFile(factory);
   factory.setSsl(getSsl(null, "password", keyStore));
   this.container = factory.getEmbeddedServletContainer();
   this.container.start();
   SSLConnectionSocketFactory socketFactory =
       new SSLConnectionSocketFactory(
           new SSLContextBuilder().loadTrustMaterial(null, new TrustSelfSignedStrategy()).build());
   HttpClient httpClient = HttpClients.custom().setSSLSocketFactory(socketFactory).build();
   HttpComponentsClientHttpRequestFactory requestFactory =
       new HttpComponentsClientHttpRequestFactory(httpClient);
   assertThat(getResponse(getLocalUrl("https", "/test.txt"), requestFactory), equalTo("test"));
 }
예제 #30
-1
  public static CloseableHttpClient buildHttpClient() throws Exception {

    TrustManager[] trustAllCerts =
        new TrustManager[] {
          new X509TrustManager() {
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
              return null;
            }

            @Override
            public void checkClientTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
                throws CertificateException {}

            @Override
            public void checkServerTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
                throws CertificateException {}
          }
        };

    SSLContext sslcontext = SSLContext.getInstance("SSL");
    sslcontext.init(null, trustAllCerts, new java.security.SecureRandom());

    // Allow TLSv1 protocol only
    SSLConnectionSocketFactory sslsf =
        new SSLConnectionSocketFactory(
            sslcontext,
            new String[] {"TLSv1"},
            null,
            SSLConnectionSocketFactory.getDefaultHostnameVerifier());
    CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();

    return httpclient;
  }