Java tutorial
/* * #%L * Wisdom-Framework * %% * Copyright (C) 2013 - 2014 Wisdom Framework * %% * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * #L% */ package org.wisdom.test.http; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.*; import org.apache.http.concurrent.FutureCallback; import org.apache.http.impl.nio.client.CloseableHttpAsyncClient; import org.ow2.chameleon.testing.helpers.TimeUtils; import org.wisdom.api.http.HeaderNames; import org.wisdom.api.http.HttpMethod; import java.util.Map; import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; /** * A couple of method easing emitting HTTP requests. */ public final class HttpClientHelper { /** * A fake user agent. */ private static final String USER_AGENT = "wisdom-test/1.1"; private HttpClientHelper() { //Unused } private static <T> FutureCallback<org.apache.http.HttpResponse> prepareCallback(final Class<T> responseClass, final Callback<T> callback) { if (callback == null) { return null; } return new FutureCallback<org.apache.http.HttpResponse>() { /** * Cancels the request. */ public void cancelled() { callback.cancelled(); } /** * Completes the request. * @param arg0 the HTTP Response */ public void completed(org.apache.http.HttpResponse arg0) { callback.completed(new HttpResponse<>(arg0, responseClass)); } /** * Marks the request as failed. * @param arg0 the error */ public void failed(Exception arg0) { callback.failed(arg0); } }; } /** * Emits an asynchronous request. * * @param request the request * @param responseClass the response class * @param callback the completion callback * @param <T> the type of the expected result * @return the future to retrieve the result */ public static <T> Future<HttpResponse<T>> requestAsync(HttpRequest request, final Class<T> responseClass, Callback<T> callback) { HttpUriRequest requestObj = prepareRequest(request); CloseableHttpAsyncClient asyncHttpClient = ClientFactory.getAsyncHttpClient(); if (!asyncHttpClient.isRunning()) { asyncHttpClient.start(); } final Future<org.apache.http.HttpResponse> future = asyncHttpClient.execute(requestObj, prepareCallback(responseClass, callback)); return new Future<HttpResponse<T>>() { /** * Cancels the request. * * @param mayInterruptIfRunning whether or not we need to interrupt the request. * @return {@literal true} if the task is successfully canceled. */ public boolean cancel(boolean mayInterruptIfRunning) { return future.cancel(mayInterruptIfRunning); } /** * @return whether the future is cancelled. */ public boolean isCancelled() { return future.isCancelled(); } /** * @return whether the result is available. */ public boolean isDone() { return future.isDone(); } /** * Gets the result. * @return the response. * @throws InterruptedException if the request is interrupted. * @throws ExecutionException if the request fails. */ public HttpResponse<T> get() throws InterruptedException, ExecutionException { org.apache.http.HttpResponse httpResponse = future.get(); return new HttpResponse<>(httpResponse, responseClass); } /** * Gets the result. * @param timeout timeout configuration * @param unit unit timeout * @return the response. * @throws InterruptedException if the request is interrupted. * @throws ExecutionException if the request fails. * @throws TimeoutException if the set time out is reached before the completion of the request. */ public HttpResponse<T> get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { org.apache.http.HttpResponse httpResponse = future.get(timeout * TimeUtils.TIME_FACTOR, unit); return new HttpResponse<>(httpResponse, responseClass); } }; } /** * Executes the request. * * @param request the request * @param responseClass the response class * @param <T> the type of content expected in the response * @return the response * @throws Exception if something bad happens. */ public static <T> HttpResponse<T> request(HttpRequest request, Class<T> responseClass) throws Exception { HttpRequestBase requestObj = prepareRequest(request); // The DefaultHttpClient is thread-safe HttpClient client = ClientFactory.getHttpClient(); org.apache.http.HttpResponse response; try { response = client.execute(requestObj); HttpResponse<T> httpResponse = new HttpResponse<>(response, responseClass); requestObj.releaseConnection(); return httpResponse; } finally { requestObj.releaseConnection(); } } private static HttpRequestBase prepareRequest(HttpRequest request) { if (!request.getHeaders().containsKey(HeaderNames.USER_AGENT)) { request.header(HeaderNames.USER_AGENT, USER_AGENT); } if (!request.getHeaders().containsKey(HeaderNames.ACCEPT_ENCODING)) { request.header(HeaderNames.ACCEPT_ENCODING, "gzip"); } Object defaultHeaders = Options.getOption(Options.Option.DEFAULT_HEADERS); if (defaultHeaders != null) { @SuppressWarnings("unchecked") Set<Map.Entry<String, String>> entrySet = ((Map<String, String>) defaultHeaders).entrySet(); for (Map.Entry<String, String> entry : entrySet) { request.header(entry.getKey(), entry.getValue()); } } HttpRequestBase reqObj = null; switch (request.getHttpMethod()) { case GET: reqObj = new HttpGet(request.getUrl()); break; case POST: reqObj = new HttpPost(request.getUrl()); break; case PUT: reqObj = new HttpPut(request.getUrl()); break; case DELETE: reqObj = new HttpDeleteWithBody(request.getUrl()); break; case OPTIONS: reqObj = new HttpOptions(request.getUrl()); break; default: break; } if (reqObj == null) { throw new IllegalStateException( "Cannot build the request - unsupported HTTP verb : " + request.getHttpMethod()); } for (Map.Entry<String, String> entry : request.getHeaders().entrySet()) { reqObj.addHeader(entry.getKey(), entry.getValue()); } // Set body if (request.getHttpMethod() != HttpMethod.GET && request.getBody() != null && reqObj instanceof HttpEntityEnclosingRequestBase) { ((HttpEntityEnclosingRequestBase) reqObj).setEntity(request.getBody().getEntity()); } return reqObj; } }