Esempio n. 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;
  }
Esempio n. 2
0
 /**
  * Prior to {@code Build()}, host, port, and endpoint must be specified.
  *
  * @return a {@link JobClient}.
  * @throws URISyntaxException
  */
 public JobClient build() throws URISyntaxException {
   // The definition of the following parameters are optional.
   if (_statusUpdateIntervalSeconds == null) {
     _statusUpdateIntervalSeconds = DEFAULT_STATUS_UPDATE_INTERVAL_SECONDS;
   }
   if (_batchRequestSize == null) {
     _batchRequestSize = DEFAULT_BATCH_REQUEST_SIZE;
   }
   if (_requestTimeoutSeconds == null) {
     _requestTimeoutSeconds = DEFAULT_REQUEST_TIMEOUT_SECONDS;
   }
   RequestConfig requestConfig =
       RequestConfig.custom()
           .setSocketTimeout(_requestTimeoutSeconds * 1000)
           .setConnectTimeout(_requestTimeoutSeconds * 1000)
           .setConnectionRequestTimeout(_requestTimeoutSeconds * 1000)
           .setStaleConnectionCheckEnabled(true)
           .build();
   _httpClientBuilder.setDefaultRequestConfig(requestConfig);
   _httpClientBuilder.setRetryHandler(new StandardHttpRequestRetryHandler());
   return new JobClient(
       Preconditions.checkNotNull(_host, "host must be set"),
       Preconditions.checkNotNull(_port, "port must be set"),
       Preconditions.checkNotNull(_endpoint, "endpoint must be set"),
       _statusUpdateIntervalSeconds,
       _batchRequestSize,
       _instanceDecorator,
       _httpClientBuilder.build());
 }
 /** 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
       }
     }
   }
 }
  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();
  }
Esempio n. 5
0
  private static HttpClient createHttpClient() {
    RequestConfig config =
        RequestConfig.custom().setSocketTimeout(TIMEOUT).setConnectTimeout(TIMEOUT).build();

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

    return hcBuilder.build();
  }
Esempio n. 6
0
 public void init() {
   if (httpClient == null) {
     RequestConfig.Builder requestBuilder = RequestConfig.custom();
     requestBuilder = requestBuilder.setConnectTimeout(bookmakerConfig.getTimeout());
     requestBuilder = requestBuilder.setConnectionRequestTimeout(bookmakerConfig.getTimeout());
     HttpClientBuilder builder = HttpClientBuilder.create();
     builder.setDefaultRequestConfig(requestBuilder.build());
     httpClient = builder.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();
 }
Esempio n. 8
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();
 }
 private ActivityClient(String host, int port, int socketTimeout) {
   RequestConfig.Builder requestBuilder = RequestConfig.custom();
   requestBuilder = requestBuilder.setConnectTimeout(socketTimeout);
   requestBuilder = requestBuilder.setConnectionRequestTimeout(socketTimeout);
   requestBuilder = requestBuilder.setSocketTimeout(socketTimeout);
   HttpClientBuilder builder = HttpClientBuilder.create();
   builder.setDefaultRequestConfig(requestBuilder.build());
   httpClient = builder.build();
   this.connectionUrl = "http://" + host + ":" + port + "/connection";
   this.queryUrl = "http://" + host + ":" + port + "/query";
   this.preparedStatementExecutionUrl =
       "http://" + host + ":" + port + "/prepared-statement-execution";
   this.batchUrl = "http://" + host + ":" + port + "/batch-execution";
   this.preparedStatementPreparationUrl =
       "http://" + host + ":" + port + "/prepared-statement-preparation";
 }
  /**
   * Configures a {@link HttpClientBuilder} to call the informed {@link BearerCredentialsSupport}
   * object to answer "bearer" challenges, such as <code>401 Unauthorized</code> responses. The
   * {@link BearerCredentialsSupport} object can return a token an hide <code>401</code> results
   * from users.
   */
  public static void configureClientBuilder(
      HttpClientBuilder httpBuilder, BearerCredentialsSupport support) {
    // Configure to use "bearer" as preferred authentication scheme (without
    // this, the client uses basic, diggest, etc).
    Builder configBuilder =
        RequestConfig.custom()
            .setTargetPreferredAuthSchemes(Arrays.asList(new String[] {BearerAuthentication.NAME}));
    httpBuilder.setDefaultRequestConfig(configBuilder.build());

    // Provide a custom "bearer" authentication provider.
    RegistryBuilder<AuthSchemeProvider> schemeProviderBuilder = RegistryBuilder.create();
    schemeProviderBuilder.register(
        BearerAuthentication.NAME, BearerAuthenticationProvider.INSTANCE);
    httpBuilder.setDefaultAuthSchemeRegistry(schemeProviderBuilder.build());

    // Configure to use the CloudCredentialsProvider.
    httpBuilder.setDefaultCredentialsProvider(new BearerCredentialsProvider(support));
  }
  public FusionPipelineClient(
      String endpointUrl, String fusionUser, String fusionPass, String fusionRealm)
      throws MalformedURLException {

    globalConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.BEST_MATCH).build();
    cookieStore = new BasicCookieStore();

    this.fusionUser = fusionUser;
    this.fusionPass = fusionPass;
    this.fusionRealm = fusionRealm;

    // build the HttpClient to be used for all requests
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    httpClientBuilder.setDefaultRequestConfig(globalConfig).setDefaultCookieStore(cookieStore);

    if (fusionUser != null && fusionRealm == null)
      httpClientBuilder.addInterceptorFirst(
          new PreEmptiveBasicAuthenticator(fusionUser, fusionPass));

    httpClient = httpClientBuilder.build();
    HttpClientUtil.setMaxConnections(httpClient, 500);
    HttpClientUtil.setMaxConnectionsPerHost(httpClient, 100);

    originalEndpoints = Arrays.asList(endpointUrl.split(","));
    try {
      sessions = establishSessions(originalEndpoints, fusionUser, fusionPass, fusionRealm);
    } catch (Exception exc) {
      if (exc instanceof RuntimeException) {
        throw (RuntimeException) exc;
      } else {
        throw new RuntimeException(exc);
      }
    }

    random = new Random();
    jsonObjectMapper = new ObjectMapper();

    requestCounter = new AtomicInteger(0);
  }
Esempio n. 12
0
  protected synchronized HttpClient getHttpClient(final String url) throws DSSException {

    if (httpClient != null) {

      return httpClient;
    } else {

      HttpClientBuilder httpClientBuilder = HttpClients.custom();

      httpClientBuilder = configCredentials(httpClientBuilder, url);

      final RequestConfig requestConfig =
          RequestConfig.custom()
              .setSocketTimeout(timeoutSocket)
              .setConnectionRequestTimeout(timeoutConnection)
              .build();
      httpClientBuilder = httpClientBuilder.setDefaultRequestConfig(requestConfig);
      httpClientBuilder.setConnectionManager(getConnectionManager());

      httpClient = httpClientBuilder.build();
      return httpClient;
    }
  }
  @Override
  @Guarded(by = STARTED)
  public HttpClientBuilder prepare(final @Nullable Customizer customizer) {
    final HttpClientPlan plan = new HttpClientPlan();

    // attach connection manager early, so customizer has chance to replace it if needed
    plan.getClient().setConnectionManager(sharedConnectionManager);

    // apply defaults
    defaultsCustomizer.customize(plan);

    // apply globals
    new ConfigurationCustomizer(getConfigurationInternal()).customize(plan);

    // apply instance customization
    if (customizer != null) {
      customizer.customize(plan);
    }

    // apply plan to builder
    HttpClientBuilder builder = plan.getClient();
    builder.setDefaultConnectionConfig(plan.getConnection().build());
    builder.setDefaultSocketConfig(plan.getSocket().build());
    builder.setDefaultRequestConfig(plan.getRequest().build());
    builder.setDefaultCredentialsProvider(plan.getCredentials());

    builder.addInterceptorFirst(
        (HttpRequest request, HttpContext context) -> {
          // add custom http-context attributes
          for (Entry<String, Object> entry : plan.getAttributes().entrySet()) {
            // only set context attribute if not already set, to allow per request overrides
            if (context.getAttribute(entry.getKey()) == null) {
              context.setAttribute(entry.getKey(), entry.getValue());
            }
          }

          // add custom http-request headers
          for (Entry<String, String> entry : plan.getHeaders().entrySet()) {
            request.addHeader(entry.getKey(), entry.getValue());
          }
        });
    builder.addInterceptorLast(
        (HttpRequest httpRequest, HttpContext httpContext) -> {
          if (outboundLog.isDebugEnabled()) {
            httpContext.setAttribute(CTX_REQ_STOPWATCH, Stopwatch.createStarted());
            httpContext.setAttribute(CTX_REQ_URI, getRequestURI(httpContext));
            outboundLog.debug(
                "{} > {}", httpContext.getAttribute(CTX_REQ_URI), httpRequest.getRequestLine());
          }
        });
    builder.addInterceptorLast(
        (HttpResponse httpResponse, HttpContext httpContext) -> {
          Stopwatch stopwatch = (Stopwatch) httpContext.getAttribute(CTX_REQ_STOPWATCH);
          if (stopwatch != null) {
            outboundLog.debug(
                "{} < {} @ {}",
                httpContext.getAttribute(CTX_REQ_URI),
                httpResponse.getStatusLine(),
                stopwatch);
          }
        });

    return builder;
  }