public synchronized HttpClientWrapper getClientWrapper() { if (m_clientWrapper == null) { m_clientWrapper = HttpClientWrapper.create() .setSocketTimeout(m_timeout) .setConnectionTimeout(m_timeout) .setRetries(m_retries) .useBrowserCompatibleCookies() .dontReuseConnections(); if(m_useSystemProxy){ m_clientWrapper.useSystemProxySettings(); post.setEntity(entity); response = m_clientWrapper.execute(post); int responseCode = response.getStatusLine().getStatusCode(); if (responseCode != HttpStatus.SC_OK) { LOG.warn("Unable to get session (by requesting user details)", e); } finally { m_clientWrapper.close(response);
return; m_clientWrapper = HttpClientWrapper.create(); if (m_request != null) { int timeout = m_request.getParameterAsInt("timeout"); if (timeout > 0) { m_clientWrapper.setConnectionTimeout(timeout) .setSocketTimeout(timeout); m_clientWrapper.setRetries(retries); if (Boolean.parseBoolean(disableSslVerification)) { try { m_clientWrapper.useRelaxedSSL("https"); } catch (final GeneralSecurityException e) { LOG.warn("Failed to set up relaxed SSL.", e); m_clientWrapper.useSystemProxySettings(); m_clientWrapper.addRequestInterceptor(new RequestAcceptEncoding()) .addResponseInterceptor(new ResponseContentEncoding()); m_clientWrapper.addBasicCredentials(uname, pwd);
m_httpMethod.setProtocolVersion(m_version); m_httpClientWrapper = HttpClientWrapper.create(); if (m_overrideSSL) { try { m_httpClientWrapper.trustSelfSigned("https"); } catch (final Exception e) { LOG.warn("Failed to create relaxed SSL client.", e); m_httpClientWrapper.setUserAgent(m_userAgent); m_httpClientWrapper.setConnectionTimeout(timeout); m_httpClientWrapper.setSocketTimeout(timeout); m_httpClientWrapper.setVirtualHost(m_virtualHost); m_httpClientWrapper.addBasicCredentials(m_userName, m_password); m_httpClientWrapper.usePreemptiveAuth(); m_httpClientWrapper.useSystemProxySettings();
public NominatimGeocoderService() { m_clientWrapper = HttpClientWrapper.create() .dontReuseConnections(); if(m_useSystemProxy) { m_clientWrapper.useSystemProxySettings(); } }
HttpClientWrapper createHttpClient() { HttpClientWrapper clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(getTimeout()) .setSocketTimeout(getTimeout()) .setRetries(getRetries()) .useBrowserCompatibleCookies(); setUseSystemProxyIfDefined(clientWrapper, m_parameterMap); return clientWrapper; } }
final HttpVersion httpVersion = computeVersion(collectorAgent.getUriDef()); clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(ParameterMap.getKeyedInteger(collectorAgent.getParameters(), ParameterName.TIMEOUT.toString(), DEFAULT_SO_TIMEOUT)) .setSocketTimeout(ParameterMap.getKeyedInteger(collectorAgent.getParameters(), ParameterName.TIMEOUT.toString(), DEFAULT_SO_TIMEOUT)) .useBrowserCompatibleCookies(); clientWrapper.useRelaxedSSL("https"); clientWrapper.setRetries(retryCount); final String userAgent = determineUserAgent(collectorAgent); if (userAgent != null && !userAgent.trim().isEmpty()) { clientWrapper.setUserAgent(userAgent); final String[] streetCred = userInfo.split(":", 2); if (streetCred.length == 2) { wrapper.addBasicCredentials(streetCred[0], streetCred[1]); } else { LOG.warn("Illegal value found for username/password HTTP credentials: {}", userInfo); final CloseableHttpResponse response = clientWrapper.execute(method);
final HttpClientWrapper clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(connectionTimeout) .setSocketTimeout(socketTimeout) .setRetries(retryCount) .useBrowserCompatibleCookies(); clientWrapper.setVirtualHost(m_config.getVirtualHost()); clientWrapper.setUserAgent(m_config.getUserAgent()); clientWrapper.useRelaxedSSL("https"); } catch (final GeneralSecurityException e) { throw new NorthbounderException("Failed to configure HTTP northbounder for relaxed SSL.", e); clientWrapper.setVersion(httpVersion); response = clientWrapper.execute(method);
@Override public void run() { final UsageStatisticsReportDTO usageStatsReport = generateReport(); final String usageStatsReportJson = usageStatsReport.toJson(); final HttpClientWrapper clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(30 * 1000) .setSocketTimeout(30 * 1000); if(m_useSystemProxy) { clientWrapper.useSystemProxySettings(); } try (CloseableHttpClient client = clientWrapper.getClient()) { HttpPost httpRequest = new HttpPost(m_url + USAGE_REPORT); httpRequest.setEntity(new StringEntity(usageStatsReportJson, ContentType.create("application/json", StandardCharsets.UTF_8))); LOG.info("Sending usage statistics report to {}: {}", httpRequest.getURI(), usageStatsReportJson); client.execute(httpRequest); LOG.info("Succesfully sent usage statistics report."); } catch (IOException e) { LOG.info("The usage statistics report was not succesfully delivered: {}", e.getMessage()); } } }
public PollStatus poll(MonitoredService svc, Map<String,Object> map) { PollStatus pollStatus = PollStatus.unresponsive(); HttpClientWrapper clientWrapper = HttpClientWrapper.create(); setUseSystemProxyIfDefined(clientWrapper, map); clientWrapper.setConnectionTimeout(ParameterMap.getKeyedInteger(map, "timeout", DEFAULT_TIMEOUT)) .setSocketTimeout(ParameterMap.getKeyedInteger(map, "timeout", DEFAULT_TIMEOUT)); clientWrapper.setUserAgent(userAgent); clientWrapper.setVirtualHost(virtualHost); clientWrapper.setVersion(HttpVersion.HTTP_1_0); clientWrapper.trustSelfSigned(ParameterMap.getKeyedString(map, "scheme", DEFAULT_SCHEME)); clientWrapper.addBasicCredentials(ParameterMap.getKeyedString(map, "auth-user", DEFAULT_USER), ParameterMap.getKeyedString(map, "auth-password", DEFAULT_PASSWORD)); if (ParameterMap.getKeyedBoolean(map, "auth-preemptive", true)) { clientWrapper.usePreemptiveAuth(); CloseableHttpResponse response = clientWrapper.execute(getMethod); int statusCode = response.getStatusLine().getStatusCode(); String statusText = response.getStatusLine().getReasonPhrase();
final HttpClientWrapper clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(3000) .setSocketTimeout(3000) .setUserAgent("OpenNMS-Ackd.HypericAckProcessor"); final String[] credentials = userinfo.split(":"); if (credentials.length == 2) { clientWrapper.addBasicCredentials(credentials[0], credentials[1]) .usePreemptiveAuth(); } else { LOG.warn("Unable to deduce username/password from '{}'", userinfo); CloseableHttpResponse response = clientWrapper.execute(httpMethod); retval = parseHypericAlerts(new StringReader(EntityUtils.toString(response.getEntity()))); } finally {
tracker.startAttempt(); clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(tracker.getSoTimeout()) .setSocketTimeout(tracker.getSoTimeout()) .setRetries(DEFAULT_RETRY); clientWrapper.trustSelfSigned(strScheme); clientWrapper.addBasicCredentials(strUser, strPasswd); CloseableHttpResponse response = clientWrapper.execute(post);
final HttpClientWrapper clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(3000) .setSocketTimeout(3000); if(getUseSystemProxy()) { clientWrapper.useSystemProxySettings(); int statusCode = -1; try { CloseableHttpResponse response = clientWrapper.execute(method); statusCode = response.getStatusLine().getStatusCode(); contents = EntityUtils.toString(response.getEntity());
@Override public Requisition getRequisitionFor(HttpRequisitionRequest request) { try (HttpClientWrapper client = HttpClientWrapper.create()) { final URI uri = new URI(request.getUrl()); HttpGet get = new HttpGet(uri); if (Boolean.FALSE.equals(request.getStrictSsl())) { client.trustSelfSigned(uri.getScheme()); } if(Boolean.TRUE.equals(request.getUseSystemProxy())){ client.useSystemProxySettings(); } if (request.getUsername() != null) { client.addBasicCredentials(request.getPassword(), request.getPassword()); } try (CloseableHttpResponse response = client.execute(get)) { String responseString = new BasicResponseHandler().handleResponse(response); return JaxbUtils.unmarshal(Requisition.class, responseString); } } catch (Exception e) { throw new RuntimeException(e); } }
void execute(final HttpClientWrapper parentClientWrapper, final MonitoredService svc, final Properties sequenceProperties) { CloseableHttpResponse response = null; try (final HttpClientWrapper clientWrapper = parentClientWrapper.duplicate()) { URI uri = getURI(svc); PageSequenceHttpUriRequest method = getMethod(uri); clientWrapper.addRequestInterceptor(new HttpRequestInterceptor() { @Override public void process(HttpRequest request, HttpContext ctx) throws HttpException, IOException { } else { HttpHost host = new HttpHost(getVirtualHost(svc), uri.getPort()); clientWrapper.setVirtualHost(host.toHostString()); clientWrapper.setVersion(HttpVersion.HTTP_0_9); break; case "1.0": clientWrapper.setVersion(HttpVersion.HTTP_1_0); break; default: clientWrapper.setVersion(HttpVersion.HTTP_1_1); break; clientWrapper.setUserAgent(getUserAgent()); } else { clientWrapper.setUserAgent("OpenNMS PageSequenceMonitor (Service name: " + svc.getSvcName() + ")"); if (Boolean.parseBoolean(m_page.getDisableSslVerification())) { try { clientWrapper.useRelaxedSSL("https"); } catch (final GeneralSecurityException e) { LOG.warn("Failed configure relaxed SSL for PageSequence {}", svc.getSvcName(), e);
/** * Test the Servlet with a simple POST Request based on XML Data. * * @throws Exception the exception */ @Test @JUnitHttpServer(port=10342, https=false, webapps={ @Webapp(context="/junit", path="src/test/resources/test-webapp") }) public void testServlet() throws Exception { String xml = "<person><firstName>Alejandro</firstName></person>"; final HttpClientWrapper clientWrapper = HttpClientWrapper.create(); try { StringEntity entity = new StringEntity(xml, ContentType.APPLICATION_XML); HttpPost method = new HttpPost("http://localhost:10342/junit/test/sample"); method.setEntity(entity); CloseableHttpResponse response = clientWrapper.execute(method); Assert.assertEquals(200, response.getStatusLine().getStatusCode()); Assert.assertEquals("OK!", EntityUtils.toString(response.getEntity())); } finally { IOUtils.closeQuietly(clientWrapper); } }
@Override public WebResponse sendRequest(final WebRequest request) throws IOException, Exception { for (final Entry<String,String> entry : request.getHeaders().entrySet()) { m_httpMethod.addHeader(entry.getKey(), entry.getValue()); } CloseableHttpResponse response = null; try { response = m_httpClientWrapper.execute(m_httpMethod); return new WebResponse(request, response); } catch (final Exception e) { LOG.info(e.getMessage(), e); return new WebResponse(request, null); } }
final HttpClientWrapper ret = HttpClientWrapper.create(); ret.m_cookieStore = m_cookieStore; ret.m_reuseConnections = m_reuseConnections;
public static void setUseSystemProxyIfDefined(HttpClientWrapper httpClientWrapper, Map<String, Object> keyedParameters) { if (ParameterMap.getKeyedBoolean(keyedParameters, useSystemProxy.getKey(), false)) { httpClientWrapper.useSystemProxySettings(); LOG.debug("setting useSystemProxySettings() on HttpClientWrapper"); } }
final HttpVersion httpVersion = computeVersion(collectorAgent.getUriDef()); clientWrapper = HttpClientWrapper.create() .setConnectionTimeout(ParameterMap.getKeyedInteger(collectorAgent.getParameters(), ParameterName.TIMEOUT.toString(), DEFAULT_SO_TIMEOUT)) .setSocketTimeout(ParameterMap.getKeyedInteger(collectorAgent.getParameters(), ParameterName.TIMEOUT.toString(), DEFAULT_SO_TIMEOUT)) .useBrowserCompatibleCookies(); clientWrapper.useRelaxedSSL("https"); clientWrapper.setRetries(retryCount); final String userAgent = determineUserAgent(collectorAgent); if (userAgent != null && !userAgent.trim().isEmpty()) { clientWrapper.setUserAgent(userAgent); final String[] streetCred = userInfo.split(":", 2); if (streetCred.length == 2) { wrapper.addBasicCredentials(streetCred[0], streetCred[1]); } else { LOG.warn("Illegal value found for username/password HTTP credentials: {}", userInfo); final CloseableHttpResponse response = clientWrapper.execute(method);