org.apache.http.client.methods.HttpRequestBase Java Examples

private HttpRequestBase createApacheRequest(HttpExecuteRequest request, String uri) {
    switch (request.httpRequest().method()) {
        case HEAD:
            return new HttpHead(uri);
        case GET:
            return new HttpGet(uri);
        case DELETE:
            return new HttpDelete(uri);
        case OPTIONS:
            return new HttpOptions(uri);
        case PATCH:
            return wrapEntity(request, new HttpPatch(uri));
        case POST:
            return wrapEntity(request, new HttpPost(uri));
        case PUT:
            return wrapEntity(request, new HttpPut(uri));
        default:
            throw new RuntimeException("Unknown HTTP method name: " + request.httpRequest().method());
    }
}
 

protected <T> T execute(HttpRequestBase request, IOFunction<T> resultConverter, Supplier<String> errorSupplier) throws IOException {
    try {
        activeExecutions.incrementAndGet();
        return client.execute(
                        request,
                        r -> {
                            if (r.getStatusLine().getStatusCode() != 200) {
                                throw new ClientProtocolException("Unable to " + errorSupplier.get() + ": " + r.getStatusLine() + " "
                                                + EntityUtils.toString(r.getEntity()));
                            } else {
                                return resultConverter.apply(r.getEntity());
                            }
                        });
    } finally {
        activeExecutions.decrementAndGet();
    }
}
 

/**
 * Call the transformation service with the export parameters in json the request body.
 *
 * @param parameters the aggregate parameters.
 * @return the http request to execute.
 */
private HttpRequestBase onExecute(AggregationParameters parameters) {
    // must work on either a dataset or a preparation, if both parameters are set, an error is thrown
    if (StringUtils.isNotBlank(parameters.getDatasetId())
            && StringUtils.isNotBlank(parameters.getPreparationId())) {
        LOG.error("Cannot aggregate on both dataset id & preparation id : {}", parameters);
        throw new TDPException(CommonErrorCodes.BAD_AGGREGATION_PARAMETERS);
    }

    String uri = transformationServiceUrl + "/aggregate"; //$NON-NLS-1$
    HttpPost aggregateCall = new HttpPost(uri);

    try {
        String paramsAsJson = objectMapper.writer().writeValueAsString(parameters);
        aggregateCall.setEntity(new StringEntity(paramsAsJson, ContentType.APPLICATION_JSON));
    } catch (JsonProcessingException e) {
        throw new TDPException(CommonErrorCodes.UNABLE_TO_AGGREGATE, e);
    }

    return aggregateCall;
}
 

@Test
public void requestTimeoutDisabled_RequestCompletesWithinTimeout_EntityNotBuffered() throws Exception {
    ClientConfiguration config = new ClientConfiguration().withRequestTimeout(0);
    ConnectionManagerAwareHttpClient rawHttpClient = createRawHttpClientSpy(config);

    HttpResponseProxy responseProxy = createHttpResponseProxySpy();
    doReturn(responseProxy).when(rawHttpClient).execute(any(HttpRequestBase.class), any(HttpContext.class));

    httpClient = new AmazonHttpClient(config, rawHttpClient, null);

    try {
        execute(httpClient, createMockGetRequest());
        fail("Exception expected");
    } catch (AmazonClientException e) {
    }

    assertResponseWasNotBuffered(responseProxy);
}
 

/**
 * {@inheritDoc}
 */
@Override
public HttpRequestBase getRequest(SipProfile acc) throws IOException {
    Betamax wizard = w.get();
    if(wizard == null) {
        return null;
    }
    String requestURL = "https://";
    String provider = wizard.providerListPref.getValue();
    if (provider != null) {
        String[] set = providers.get(provider);
        requestURL += set[0].replace("sip.", "www.");
        requestURL += "/myaccount/getbalance.php";
        requestURL += "?username=" + acc.username;
        requestURL += "&password=" + acc.data;

        return new HttpGet(requestURL);
    }
    return null;
}
 

@Override
public HttpResponse answer(InvocationOnMock invocation) throws Throwable {
	HttpHost host = (HttpHost) invocation.getArguments()[0];
	HttpRequestBase request = (HttpRequestBase) invocation.getArguments()[1];
	HttpContext context = (HttpContext) invocation.getArguments()[2];

	InputStream response = null;
	if(request instanceof HttpGet)
		response = doGet(host, (HttpGet) request, context);
	else if(request instanceof HttpPost)
		response = doPost(host, (HttpPost) request, context);
	else if(request instanceof HttpPut)
		response = doPut(host, (HttpPut) request, context);
	else
		throw new Exception("mock method not implemented");

	return buildResponse(response);
}
 

private String sendAndGetResponse(HttpRequestBase request) throws IOException {
  String data = StringUtils.EMPTY;
  try {
    HttpResponse response = client.execute(request, null).get(30, TimeUnit.SECONDS);
    int code = response.getStatusLine().getStatusCode();
    if (code == 200) {
      try (InputStream responseContent = response.getEntity().getContent()) {
        data = IOUtils.toString(responseContent, "UTF-8");
      }
    } else {
      LOG.error("ZeppelinHub {} {} returned with status {} ", request.getMethod(),
          request.getURI(), code);
      throw new IOException("Cannot perform " + request.getMethod() + " request to ZeppelinHub");
    }
  } catch (InterruptedException | ExecutionException | TimeoutException
      | NullPointerException e) {
    throw new IOException(e);
  }
  return data;
}
 

private HttpRequestBase onExecute(String preparationId, String stepId, AppendStep updatedStep) {
    try {
        final String url = preparationServiceUrl + "/preparations/" + preparationId + "/actions/" + stepId;

        final Optional<StepDiff> firstStepDiff = toStream(StepDiff.class, objectMapper, input).findFirst();
        if (firstStepDiff.isPresent()) { // Only interested in first one
            final StepDiff diff = firstStepDiff.get();
            updatedStep.setDiff(diff);
        }
        final String stepAsString = objectMapper.writeValueAsString(updatedStep);

        final HttpPut actionAppend = new HttpPut(url);
        final InputStream stepInputStream = new ByteArrayInputStream(stepAsString.getBytes());

        actionAppend.setHeader(new BasicHeader(CONTENT_TYPE, APPLICATION_JSON_VALUE));
        actionAppend.setEntity(new InputStreamEntity(stepInputStream));
        return actionAppend;
    } catch (IOException e) {
        throw new TDPException(CommonErrorCodes.UNEXPECTED_EXCEPTION, e);
    }
}
 

/**
 * GET object
 *
 * @param path path to the object
 * @param account Joss Account wrapper object
 * @param bytesFrom from from
 * @param bytesTo bytes to
 * @param scm Swift Connection manager
 * @return SwiftInputStreamWrapper that includes input stream and length
 * @throws IOException if network errors
 */
public static SwiftInputStreamWrapper getObject(
        final Path path,
        final JossAccount account,
        final long bytesFrom,
        final long bytesTo,
        final SwiftConnectionManager scm) throws IOException {
  Tuple<Integer, Tuple<HttpRequestBase, HttpResponse>> resp = httpGET(
          path.toString(),
          bytesFrom,
          bytesTo,
          account,
          scm);
  if (resp.x.intValue() >= 400) {
    LOG.warn("Re-authentication attempt for GET {}", path.toString());
    account.authenticate();
    resp = httpGET(path.toString(), bytesFrom, bytesTo, account, scm);
  }

  final SwiftInputStreamWrapper httpStream = new SwiftInputStreamWrapper(
      resp.y.y.getEntity(), resp.y.x
  );
  return httpStream;
}
 

public static void validateSchemaList(SCIMObject scimObject,
                                      SCIMResourceTypeSchema resourceSchema,
                                      HttpRequestBase method,
                                      String responseString,
                                      String headerString,
                                      String responseStatus,
                                      ArrayList<String> subTests)
        throws GeneralComplianceException, ComplianceException {

    //get resource schema list
    List<String> resourceSchemaList = resourceSchema.getSchemasList();
    //get the scim object schema list
    List<String> objectSchemaList = scimObject.getSchemaList();

    for (String schema : resourceSchemaList) {
        //check for schema.
        if (!objectSchemaList.contains(schema)) {
            throw new GeneralComplianceException(new TestResult(TestResult.ERROR, "Schema List Test",
                    "Not all schemas are set", ComplianceUtils.getWire(method,
                    responseString, headerString, responseStatus, subTests)));
        }
    }
}
 

/**
 * {@inheritDoc }
 */
@Override
public ODataInvokeResponse<T> execute() {
  final InputStream input = getPayload();

  if (!this.parameters.isEmpty()) {
    if (this.method == HttpMethod.GET) {
      ((HttpRequestBase) this.request).setURI(
          URIUtils.buildFunctionInvokeURI(this.uri, parameters));
    } else if (this.method == HttpMethod.POST) {
      ((HttpPost) request).setEntity(URIUtils.buildInputStreamEntity(odataClient, input));

      setContentType(getActualFormat(getPOSTParameterFormat()));
    }
  }

  try {
    return new ODataInvokeResponseImpl(odataClient, httpClient, doExecute());
  } finally {
    IOUtils.closeQuietly(input);
  }
}
 

@Override
protected HttpResponse doExecute() throws Exception {
	final HttpMethod method = getMethod();

	final HttpRequestBase httpRequest = FACTORY.create(method);

	httpRequest.setURI(createRequestURI());
	handleBody(httpRequest);
	handleHeaders(httpRequest);
	handleCookies(httpRequest);

	final long start = nanoTime();
	final org.apache.http.HttpResponse httpResponse = client.execute(httpRequest);
	final long duration = nanoTime() - start;

	return ApacheHttpResponseFactory.of(httpResponse, duration);
}
 

private HttpRequestBase onExecute(final String parentId, final Sort sort, final Order order) {
    try {
        String uri = preparationServiceUrl + "/folders";
        final URIBuilder uriBuilder = new URIBuilder(uri);
        if (parentId != null) {
            uriBuilder.addParameter("parentId", parentId);
        }
        if (sort != null) {
            uriBuilder.addParameter("sort", sort.camelName());
        }
        if (order != null) {
            uriBuilder.addParameter("order", order.camelName());
        }

        return new HttpGet(uriBuilder.build());

    } catch (URISyntaxException e) {
        throw new TDPException(CommonErrorCodes.UNEXPECTED_EXCEPTION, e);
    }
}
 

private static String httpRequestBaseParse(Object obj) throws IOException {
	HttpRequestBase request = (HttpRequestBase)obj;
	StringBuilder sb = new StringBuilder();

	Header[] headers = request.getAllHeaders();
	sb.append(request.getRequestLine().toString()+"\n");

	for (Header header : headers) {
		sb.append(header.getName() + ": " + header.getValue()+"\n");
	}

	sb.append("\n");

	if(request instanceof HttpPost)
		sb.append( EntityUtils.toString(((HttpPost) request).getEntity()));

	return sb.toString();
}
 

public String getHttp(String url, List<NameValuePair> headers) throws IOException
{
    HttpRequestBase request = new HttpGet(url);

    if (headers != null)
    {
        for (NameValuePair header : headers)
        {
            request.addHeader(header.getName(), header.getValue());
        }
    }

    HttpClient httpClient = HttpClientBuilder.create().setProxy(proxy).build();
    HttpResponse response = httpClient.execute(request);

    HttpEntity entity = response.getEntity();
    if (entity != null)
    {
        return EntityUtils.toString(entity);

    }
    return null;
}
 

@Test
void shouldPassAllParametersToPostForRegistrationOfNonElasticAgent() throws IOException {
    String url = "http://cruise.com/go";
    GoAgentServerHttpClient httpClient = mock(GoAgentServerHttpClient.class);
    final CloseableHttpResponse response = mock(CloseableHttpResponse.class);
    final ProtocolVersion protocolVersion = new ProtocolVersion("https", 1, 2);
    when(response.getStatusLine()).thenReturn(new BasicStatusLine(protocolVersion, HttpStatus.OK.value(), null));
    when(response.getEntity()).thenReturn(new StringEntity(""));
    when(httpClient.execute(isA(HttpRequestBase.class))).thenReturn(response);
    final DefaultAgentRegistry defaultAgentRegistry = new DefaultAgentRegistry();
    Properties properties = new Properties();
    properties.put(AgentAutoRegistrationPropertiesImpl.AGENT_AUTO_REGISTER_KEY, "t0ps3cret");
    properties.put(AgentAutoRegistrationPropertiesImpl.AGENT_AUTO_REGISTER_RESOURCES, "linux, java");
    properties.put(AgentAutoRegistrationPropertiesImpl.AGENT_AUTO_REGISTER_ENVIRONMENTS, "uat, staging");
    properties.put(AgentAutoRegistrationPropertiesImpl.AGENT_AUTO_REGISTER_HOSTNAME, "agent01.example.com");

    remoteRegistryRequester(url, httpClient, defaultAgentRegistry, 200).requestRegistration("cruise.com", new AgentAutoRegistrationPropertiesImpl(null, properties));
    verify(httpClient).execute(argThat(hasAllParams(defaultAgentRegistry.uuid(), "", "")));
}
 

public HttpRequestBase getRequest() {
    if (target == null) {
        throw new IllegalStateException("ServiceCommand has no target url");
    }

    if (this.httpMethod.equalsIgnoreCase(TYPE_GET)) {
        return new HttpGet(target);
    } else if (this.httpMethod.equalsIgnoreCase(TYPE_POST)) {
        return new HttpPost(target);
    } else if (this.httpMethod.equalsIgnoreCase(TYPE_DEL)) {
        return new HttpDelete(target);
    } else if (this.httpMethod.equalsIgnoreCase(TYPE_PUT)) {
        return new HttpPut(target);
    } else {
        return null;
    }
}
 

/**
 * 发送 http 请求
 * @param httpRequestBase request
 * @param client http client
 * @return response
 */
private String sendRequest(HttpRequestBase httpRequestBase,HttpClient client){
    String result = null;
    try {
        HttpResponse response = client.execute(httpRequestBase);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            HttpEntity httpEntity = response.getEntity();
            result = EntityUtils.toString(httpEntity, "UTF-8");
            EntityUtils.consume(httpEntity);
        } else {
            log.error("请求异常：{},{}", httpRequestBase.getURI(), response.getStatusLine());
        }
        return result;
    } catch (IOException e) {
        log.error("请求异常：{},{}", httpRequestBase.getURI(), e.getMessage());
    }
    return "";
}
 

/**
 * Sets basic auth header to either the one in the SolrRequest or the one stored in this client.
 * <p>
 * DEV NOTE: Derived from <code>HttpSolrClient#setBasicAuthHeader</code>, which is private in superclass.
 */
@SuppressWarnings("rawtypes")
protected void setBasicAuthHeaderScipio(SolrRequest request, HttpRequestBase method) throws UnsupportedEncodingException {
    if (request.getBasicAuthUser() != null && request.getBasicAuthPassword() != null) {
        setBasicAuthHeader(method, request.getBasicAuthUser(), request.getBasicAuthPassword());
    } else if (this.solrUsername != null && this.solrPassword != null) {
        setBasicAuthHeader(method, this.solrUsername, this.solrPassword);
    }
}
 

protected HttpResponse executeGetOrHead(HttpRequestBase method) throws IOException {
    HttpResponse httpResponse = performHttpRequest(method);
    // Consume content for non-successful, responses. This avoids the connection being left open.
    if (!wasSuccessful(httpResponse)) {
        EntityUtils.consume(httpResponse.getEntity());
        return httpResponse;
    }
    return httpResponse;
}
 

public HttpResponse performRequest(HttpRequestBase request) {
    String method = request.getMethod();

    HttpResponse response;
    try {
        response = executeGetOrHead(request);
    } catch (IOException e) {
        throw new HttpRequestException(String.format("Could not %s '%s'.", method, request.getURI()), e);
    }

    return response;
}
 

private void addRequestConfig(final HttpRequestBase base,
                              final SdkHttpRequest request,
                              final ApacheHttpRequestConfig requestConfig) {
    int connectTimeout = saturatedCast(requestConfig.connectionTimeout().toMillis());
    int connectAcquireTimeout = saturatedCast(requestConfig.connectionAcquireTimeout().toMillis());
    RequestConfig.Builder requestConfigBuilder = RequestConfig
            .custom()
            .setConnectionRequestTimeout(connectAcquireTimeout)
            .setConnectTimeout(connectTimeout)
            .setSocketTimeout(saturatedCast(requestConfig.socketTimeout().toMillis()))
            .setLocalAddress(requestConfig.localAddress());

    ApacheUtils.disableNormalizeUri(requestConfigBuilder);

    /*
     * Enable 100-continue support for PUT operations, since this is
     * where we're potentially uploading large amounts of data and want
     * to find out as early as possible if an operation will fail. We
     * don't want to do this for all operations since it will cause
     * extra latency in the network interaction.
     */
    if (SdkHttpMethod.PUT == request.method() && requestConfig.expectContinueEnabled()) {
        requestConfigBuilder.setExpectContinueEnabled(true);
    }

    base.setConfig(requestConfigBuilder.build());
}
 

private HttpRequestBase onExecute(final String id) {
    try {
        URIBuilder uriBuilder = new URIBuilder(preparationServiceUrl + "/folders/" + id);
        return new HttpGet(uriBuilder.build());
    } catch (URISyntaxException e) {
        throw new TDPException(CommonErrorCodes.UNEXPECTED_EXCEPTION, e);
    }
}
 

@Test
void buildPostWithContent() throws HttpRequestBuildException, IOException
{
    HttpRequestBase request = builder.withHttpMethod(HttpMethod.POST).withEndpoint(ENDPOINT).withContent(CONTENT)
            .build();
    assertRequestWithContent(request, HttpMethod.POST.name(), ENDPOINT, CONTENT);
}
 

/**
 * @param parameters the export parameters.
 * @return the request to perform.
 */
private HttpRequestBase onExecute(ExportParameters parameters) {
    try {
        final String parametersAsString =
                objectMapper.writerFor(ExportParameters.class).writeValueAsString(parameters);
        final HttpPost post = new HttpPost(transformationServiceUrl + "/apply");
        post.setEntity(new StringEntity(parametersAsString, ContentType.APPLICATION_JSON));
        return post;
    } catch (Exception e) {
        throw new TDPException(APIErrorCodes.UNABLE_TO_EXPORT_CONTENT, e);
    }
}
 

/**
 * @param header
 * @param httpRequestBase
 */
private void handlerHeader(Map<String, String> header, HttpRequestBase httpRequestBase) {
    if (Check.isNullOrEmpty(header)) {
        return;
    }
    Iterator<String> iterator = header.keySet().iterator();
    while (iterator.hasNext()) {
        String headerName = iterator.next();
        httpRequestBase.addHeader(headerName, header.get(headerName));
    }
}
 

public <T> BaseResponse<T> invokeCGI(HttpRequestBase request, TypeReference<BaseResponse<T>> typeReference) throws BrokerException {
    long requestStartTime = System.currentTimeMillis();
    RequestConfig requestConfig = RequestConfig.custom()
            .setConnectTimeout(this.timeout)
            .setSocketTimeout(this.timeout)
            .build();
    request.setConfig(requestConfig);
    try (CloseableHttpResponse httpResponse = this.httpClient.execute(request)) {
        log.info("invokeCGI {} in {} millisecond, response:{}", request.getURI(),
                System.currentTimeMillis() - requestStartTime, httpResponse.getStatusLine().toString());
        if (HttpStatus.SC_OK != httpResponse.getStatusLine().getStatusCode()) {
            log.error("invokeCGI failed, request url:{}, msg:{}", request.getURI(), httpResponse.getStatusLine().toString());
            throw new BrokerException(ErrorCode.HTTP_RESPONSE_FAILED);
        }
        if (null == httpResponse.getEntity()) {
            log.error("invokeCGI failed, httpResponse.getEntity is null, request url:{}", request.getURI());
            throw new BrokerException(ErrorCode.HTTP_RESPONSE_ENTITY_EMPTY);
        }

        byte[] responseResult = EntityUtils.toByteArray(httpResponse.getEntity());
        BaseResponse<T> baseResponse = JsonHelper.json2Object(responseResult, typeReference);

        if (ErrorCode.SUCCESS.getCode() != baseResponse.getCode()) {
            log.error("invokeCGI failed, request url:{}, msg:{}", request.getURI(), baseResponse.getMessage());
            throw new BrokerException(baseResponse.getCode(), baseResponse.getMessage());
        }

        return baseResponse;
    } catch (IOException e) {
        log.error("invokeCGI error, request url:{}", request.getURI(), e);
        throw new BrokerException(ErrorCode.HTTP_REQUEST_EXECUTE_ERROR);
    }
}
 

private HttpRequestBase onExecute(String id) {
    try {
        URIBuilder uriBuilder = new URIBuilder(preparationServiceUrl + "/steps/" + id);
        return new HttpGet(uriBuilder.build());
    } catch (URISyntaxException e) {
        throw new TDPException(UNEXPECTED_EXCEPTION, e);
    }
}
 

@Override
protected HttpRequestBase getRequest(RequestModel requestModel) {
    HttpPost httpPost=new HttpPost(requestModel.getTestUrl());
    try {
        httpPost.setEntity(new StringEntity(requestModel.getRequest(),"UTF-8"));
    } catch (Exception e) {
    }
    return httpPost;
}
 

protected void closeQuietly(HttpRequestBase httpRequest, CloseableHttpResponse httpResponse, CloseableHttpClient client) {
	try {
		if (httpRequest != null) {
			httpRequest.releaseConnection();
		}
		if (httpResponse != null) {
			EntityUtils.consumeQuietly(httpResponse.getEntity());
			Utils.closeQuietly(httpResponse);
		}
	} finally {
		Utils.closeQuietly(client);
	}
}