// Interface to AsyncHttpRequest
@Override
protected void sendResponseMessage(HttpResponse response) {
StatusLine status = response.getStatusLine();
Header[] contentTypeHeaders = response.getHeaders("Content-Type");
byte[] responseBody = null;
if (contentTypeHeaders.length != 1) {
// malformed/ambiguous HTTP Header, ABORT!
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
new HttpResponseException(
status.getStatusCode(), "None, or more than one, Content-Type Header found!"),
(String) null);
return;
}
Header contentTypeHeader = contentTypeHeaders[0];
boolean foundAllowedContentType = false;
for (String anAllowedContentType : mAllowedContentTypes) {
if (Pattern.matches(anAllowedContentType, contentTypeHeader.getValue())) {
foundAllowedContentType = true;
}
}
if (!foundAllowedContentType) {
// Content-Type not in allowed list, ABORT!
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
new HttpResponseException(status.getStatusCode(), "Content-Type not allowed!"),
(String) null);
return;
}
try {
HttpEntity entity = null;
HttpEntity temp = response.getEntity();
if (temp != null) {
entity = new BufferedHttpEntity(temp);
}
responseBody = EntityUtils.toByteArray(entity);
} catch (IOException e) {
sendFailureMessage(status.getStatusCode(), response.getAllHeaders(), e, (byte[]) null);
}
if (status.getStatusCode() >= 300) {
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()),
responseBody);
} else {
sendSuccessMessage(status.getStatusCode(), responseBody);
}
}
private void processRequest(HttpRequest request, Socket client)
throws IllegalStateException, IOException {
if (request == null) {
return;
}
Log.d(LOG_TAG, "processing");
String url = request.getRequestLine().getUri();
HttpResponse realResponse = download(url);
if (realResponse == null) {
return;
}
Log.d(LOG_TAG, "downloading...");
BufferedInputStream data = new BufferedInputStream(realResponse.getEntity().getContent());
StatusLine line = realResponse.getStatusLine();
HttpResponse response = new BasicHttpResponse(line);
response.setHeaders(realResponse.getAllHeaders());
Log.d(LOG_TAG, "reading headers");
StringBuilder httpString = new StringBuilder();
httpString.append(response.getStatusLine().toString());
httpString.append("\n");
for (Header h : response.getAllHeaders()) {
httpString.append(h.getName()).append(": ").append(h.getValue()).append("\n");
}
httpString.append("\n");
Log.d(LOG_TAG, "headers done");
try {
byte[] buffer = httpString.toString().getBytes();
int readBytes;
Log.d(LOG_TAG, "writing to client");
BufferedOutputStream bos = new BufferedOutputStream(client.getOutputStream());
bos.write(buffer, 0, buffer.length);
// Start streaming content.
byte[] buff = new byte[1024 * 50];
while (isRunning && (readBytes = data.read(buff, 0, buff.length)) != -1) {
bos.write(buff, 0, readBytes);
}
} catch (Exception e) {
Log.e("", e.getMessage(), e);
} finally {
if (data != null) {
data.close();
}
client.close();
}
}
/**
* This method processes the response and extracts the JSON string from the HTTP response code.
*
* @param httpResponse The HttpResponse returned
*/
protected RestClientResponse processHttpResponse(HttpResponse httpResponse) throws Exception {
final String json;
if (httpResponse == null) {
LOGGER.error(NULL_HTTP_RESPONSE.getLogMessage(commandName));
throw new JsonReadException(NULL_HTTP_RESPONSE);
}
final int httpStatusCode = httpResponse.getStatusLine().getStatusCode();
if (httpStatusCode == HttpStatus.SC_NO_CONTENT && httpResponse.getEntity() == null) {
LOGGER.debug("Http No Content response from the {} resource with null payload.", commandName);
return null;
}
LOGGER.debug("HTTP status code returned by the REST resource is --> {}", httpStatusCode);
HttpEntity entity = httpResponse.getEntity();
try {
json = EntityUtils.toString(entity, "UTF-8");
LOGGER.debug(httpResponse.getStatusLine().toString());
} catch (ParseException | IllegalArgumentException | IOException ex) {
LOGGER.error(JSON_READ_FAILED.getLogMessage(commandName), ex);
throw new JsonReadException(JSON_READ_FAILED, ex);
}
return new RestClientResponse(json, httpStatusCode, httpResponse.getAllHeaders());
}
@Test
public void testGet() throws ClientProtocolException, IOException, URISyntaxException {
HttpClient httpclient = new DefaultHttpClient();
URIBuilder builder = new URIBuilder();
builder.setScheme("http").setHost("localhost").setPort(8080).setPath("/immortal/register");
builder.setParameter("userid", "value1").setParameter("username", "用户名");
URI uri = builder.build();
HttpGet httpget = new HttpGet(uri);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
for (Header header : response.getAllHeaders()) {
System.out.println(header);
}
System.out.println(response.getStatusLine());
System.out.println(HttpStatus.SC_OK);
if (entity != null) {
InputStream instream = entity.getContent();
InputStreamReader reader = new InputStreamReader(instream);
try {
while (instream.available() > 0) {
System.out.print((char) instream.read());
}
int c;
StringBuilder sb = new StringBuilder();
while ((c = reader.read()) > -1) sb.append((char) c);
System.out.println(sb);
} finally {
reader.close();
}
}
}
public static void headerRequest() {
try {
HttpClient client = HttpClientBuilder.create().build();
HttpGet request = new HttpGet("http://mkyong.com");
HttpResponse response = client.execute(request);
System.out.println("Printing Response Header...\n");
Header[] headers = response.getAllHeaders();
for (Header header : headers) {
System.out.println("Key : " + header.getName() + " ,Value : " + header.getValue());
}
System.out.println("\nGet Response Header By Key ...\n");
String server = response.getFirstHeader("Server").getValue();
if (server == null) {
System.out.println("Key 'Server' is not found!");
} else {
System.out.println("Server - " + server);
}
System.out.println("\n Done");
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
protected String doInBackground(String... url) {
if (allPhoneContacts != null) {
allPhoneContacts.clear();
}
if (syncedContacts != null) {
syncedContacts.clear();
}
String resp = "";
Header[] responseHeaders = null;
HttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParams, TIMEOUT_MILLSEC);
HttpGet request = new HttpGet(url[0]);
MyHttpClient Client = LogonClass.Client;
Client.putContext(context);
try {
request.setHeader("syncstatus", "True");
HttpResponse response = Client.execute(request);
resp = EntityUtils.toString(response.getEntity());
responseHeaders = response.getAllHeaders();
} catch (Exception e) {
resp = "none is righteous";
}
Log.v(TAG, "response is " + resp);
return resp;
}
/**
* Writes the specified TaskResult data to the channel output. Only the raw output data is written
* and rest of the TaskResult fields are ignored
*
* @param ctx the ChannelHandlerContext
* @param event the ChannelEvent
* @throws Exception in case of any errors
*/
private void writeCommandExecutionResponse(
ChannelHandlerContext ctx, ChannelEvent event, HttpResponse response) throws Exception {
// Don't write anything if the response is null
if (response == null) {
// write empty response
event
.getChannel()
.write(new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NO_CONTENT))
.addListener(ChannelFutureListener.CLOSE);
return;
}
org.jboss.netty.handler.codec.http.HttpResponse httpResponse =
new DefaultHttpResponse(
HttpVersion.HTTP_1_1,
HttpResponseStatus.valueOf(response.getStatusLine().getStatusCode()));
// write headers
for (Header header : response.getAllHeaders()) {
if (!RoutingHttpChannelHandler.REMOVE_HEADERS.contains(header.getName())) {
httpResponse.setHeader(header.getName(), header.getValue());
}
}
// write entity
HttpEntity responseEntity = response.getEntity();
byte[] responseData = EntityUtils.toByteArray(responseEntity);
httpResponse.setContent(ChannelBuffers.copiedBuffer(responseData));
// write response
event.getChannel().write(httpResponse).addListener(ChannelFutureListener.CLOSE);
}
/**
* Intialise myExperiment session
*
* @return Session handler string
*/
public void createNewMyExperimentSession() throws DefaultHttpClientException {
// get myExperiment session
String myExperimentSessionStr = null;
try {
String sessRequest =
"<session><username>"
+ user
+ "</username><password>"
+ password
+ "</password></session>";
HttpResponse sessionResponse =
myExpRestClient.executeStringPost("/session", sessRequest, ContentType.APPLICATION_XML);
InputStream is = sessionResponse.getEntity().getContent();
Header[] headers = sessionResponse.getAllHeaders();
for (int i = 0; i < headers.length; i++) {
Header h = headers[i];
if (h.getName().equals("Set-Cookie")) {
String val = h.getValue();
int end = val.indexOf(";");
myExperimentSessionStr = val.substring(0, end);
}
}
EntityUtils.consume(sessionResponse.getEntity());
myExperimentSession = myExperimentSessionStr;
} catch (Exception ex) {
throw new DefaultHttpClientException(ex.getMessage());
}
}
private HttpResponseBean buildHttpResponseBean(
HttpResponse httpResponse, String response, Date requestTime, Date responseTime) {
HttpResponseBean httpResponseBean = new HttpResponseBean();
Header[] headersArray = httpResponse.getAllHeaders();
Map<String, String> headersMap = new HashMap<String, String>();
for (Header header : headersArray) {
String[] headerAttributes = header.toString().split(": ");
headersMap.put(headerAttributes[0], headerAttributes[1].replace("\r\n", ""));
}
httpResponseBean.setResponseHeaders(headersMap);
httpResponseBean.setHttpStatusCode(httpResponse.getStatusLine().getStatusCode());
httpResponseBean.setHttpStatusText(httpResponse.getStatusLine().getReasonPhrase());
httpResponseBean.setRequestTime(new Timestamp(requestTime.getTime()));
httpResponseBean.setResponseTime(new Timestamp(responseTime.getTime()));
if ((response != null) && (!response.equalsIgnoreCase(""))) {
httpResponseBean.setResponseObject(response);
} else {
httpResponseBean.setResponseObject(null);
}
return httpResponseBean;
}
@Test
public void GetRequest()
throws URISyntaxException, ClientProtocolException, IOException, ParserConfigurationException,
UnsupportedOperationException, SAXException {
HttpUriRequest request = new HttpGet(url);
URIBuilder uri = new URIBuilder(request.getURI()).addParameter("CountryName", country);
((HttpRequestBase) request).setURI(uri.build());
// Testing headers
HttpResponse response = client.execute(request);
Header[] headers = response.getAllHeaders();
for (Header head : headers) {
System.out.println(head.getName() + "---" + head.getValue());
}
System.out.println("================================================");
// Testing response
// parsing xml
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(response.getEntity().getContent());
// Printing root
doc.getDocumentElement().normalize();
NodeList nList = doc.getElementsByTagName("string");
Node aNode = nList.item(0);
Element element = (Element) aNode;
System.out.println(element.getFirstChild());
}
@Override
public void process(HttpResponse response, HttpContext context)
throws HttpException, IOException {
CookieStore cookieStore = (CookieStore) context.getAttribute(ClientContext.COOKIE_STORE);
for (Header header : response.getAllHeaders()) {
if (!header.getName().equalsIgnoreCase("Set-Cookie")) {
continue;
}
Matcher matcher = pattern.matcher(header.getValue());
if (!matcher.find()) {
continue;
}
for (Cookie cookie : cookieStore.getCookies()) {
if (cookie.getName().equalsIgnoreCase(matcher.group(1))) {
if (cookie instanceof BasicClientCookie) {
((BasicClientCookie) cookie).setValue('"' + cookie.getValue() + '"');
} else if (cookie instanceof BasicClientCookie2) {
((BasicClientCookie2) cookie).setValue('"' + cookie.getValue() + '"');
} else {
Log.w(TAG, "unhandled cookie implementation " + cookie.getClass().getName());
}
break;
}
}
}
}
public final void sendResponseMessage(HttpResponse paramHttpResponse) {
int i = 0;
StatusLine localStatusLine = paramHttpResponse.getStatusLine();
Header[] arrayOfHeader = paramHttpResponse.getHeaders("Content-Type");
if (arrayOfHeader.length != 1) {
sendFailureMessage(
localStatusLine.getStatusCode(),
paramHttpResponse.getAllHeaders(),
null,
new HttpResponseException(
localStatusLine.getStatusCode(),
"None, or more than one, Content-Type Header found!"));
return;
}
Header localHeader = arrayOfHeader[0];
String[] arrayOfString = getAllowedContentTypes();
int j = arrayOfString.length;
int k = 0;
for (; ; ) {
if (k < j) {
String str = arrayOfString[k];
try {
boolean bool = Pattern.matches(str, localHeader.getValue());
if (bool) {
i = 1;
}
k++;
} catch (PatternSyntaxException localPatternSyntaxException) {
for (; ; ) {
Log.e(
"BinaryHttpResponseHandler",
"Given pattern is not valid: " + str,
localPatternSyntaxException);
}
}
}
}
if (i == 0) {
sendFailureMessage(
localStatusLine.getStatusCode(),
paramHttpResponse.getAllHeaders(),
null,
new HttpResponseException(localStatusLine.getStatusCode(), "Content-Type not allowed!"));
return;
}
super.sendResponseMessage(paramHttpResponse);
}
@Override
protected Boolean doInBackground(String... params) {
Instrumentation.startTimer("UserLoginTask");
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost =
new HttpPost(GlobalDataProvider.getInstance().getRestServiceUrl() + "user/login");
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);
nameValuePairs.add(new BasicNameValuePair("username", params[0]));
nameValuePairs.add(new BasicNameValuePair("password", params[1]));
try {
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
Log.d(TAG, httppost.getRequestLine().getUri());
HttpResponse response = httpclient.execute(httppost);
if (response != null && response.getEntity() != null) {
String respStr = EntityUtils.toString(response.getEntity());
if (respStr != null && respStr.equalsIgnoreCase("Success")) {
Header[] headers = response.getAllHeaders();
for (Header header : headers) {
if ("set-cookie".equalsIgnoreCase(header.getName())) {
String headerValue = header.getValue();
if (headerValue.startsWith(JSESSIONID)) {
String jsessionId = headerValue.substring(0, headerValue.indexOf(';'));
GlobalDataProvider.getInstance().setSessionId(jsessionId);
}
}
}
// TODO: Future enhancements - register the new account here??
success = true;
Log.d("ADInstrumentation", "success");
return true;
} else {
error = true;
}
} else {
exceptionOccured = true;
exceptionMessage = "Unable to connect to server";
}
} catch (UnsupportedEncodingException e1) {
exceptionOccured = true;
e1.getLocalizedMessage();
e1.printStackTrace();
} catch (ClientProtocolException e) {
exceptionOccured = true;
exceptionMessage = e.getLocalizedMessage();
e.printStackTrace();
} catch (IOException e) {
exceptionOccured = true;
exceptionMessage = e.getLocalizedMessage();
e.printStackTrace();
} finally {
Instrumentation.stopTimer("UserLoginTask");
}
Log.d("ADInstrumentation", "failure");
return false;
}
public static CaseInsensitiveMap<String> extractHeaders(HttpResponse response) {
final CaseInsensitiveMap<String> headers = new CaseInsensitiveMap<String>();
for (Header header : response.getAllHeaders()) {
headers.add(header.getName(), header.getValue());
}
return headers;
}
public Response makeRequest(
Methods method, URI uri, HashMap<String, String> requestHeaders, String data) {
HttpRequestBase request = null;
try {
if (method == Methods.GET) {
request = new HttpGet();
} else if (method == Methods.POST) {
request = new HttpPost();
if (data != null) {
((HttpPost) request).setEntity(new StringEntity(data, "UTF-8"));
}
} else if (method == Methods.PUT) {
request = new HttpPut();
if (data != null) {
((HttpPut) request).setEntity(new StringEntity(data, "UTF-8"));
}
} else if (method == Methods.DELETE) {
request = new HttpDelete();
}
} catch (UnsupportedEncodingException e) {
logger.log(e);
}
request.setURI(uri);
AndroidHttpClient client = AndroidHttpClient.newInstance(userAgent);
if (requestHeaders != null) {
for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
request.addHeader(new BasicHeader(entry.getKey(), entry.getValue()));
}
}
HttpResponse response = null;
Response retVal = new Response();
retVal.headers = new HashMap<String, String>();
try {
response = client.execute(request);
} catch (SocketTimeoutException e) {
// forget it--we don't care that the user couldn't connect
// TODO hand this back as an error to JS
} catch (IOException e) {
if (!caughtIOException) {
caughtIOException = true;
logger.log(e);
}
} catch (Exception e) {
logger.log(e);
}
if (response != null) {
retVal.status = response.getStatusLine().getStatusCode();
retVal.body = readContent(response);
for (Header header : response.getAllHeaders()) {
retVal.headers.put(header.getName(), header.getValue());
}
}
client.close();
return retVal;
}
public Map<String, List<String>> getHeaderFields() {
Map<String, List<String>> ret = new HashMap<String, List<String>>();
for (Header hdr : resp.getAllHeaders()) {
List<String> list = new LinkedList<String>();
for (HeaderElement hdrElem : hdr.getElements()) list.add(hdrElem.toString());
ret.put(hdr.getName(), list);
}
return ret;
}
public Multimap<String, String> headers() {
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (Header header : httpResponse.getAllHeaders()) {
builder.put(header.getName(), header.getValue());
}
return builder.build();
}
@Override
public Map<String, String> handleResponse(HttpResponse response) throws IOException {
this.validateResponse(response);
Map<String, String> headers = new HashMap<String, String>();
for (Header h : response.getAllHeaders()) {
headers.put(h.getName(), h.getValue());
}
return headers;
}
/**
* 从响应结果中获取Header信息，返回map表
*
* @param res
* @return Map<String, String>
*/
private Map<String, String> getResHeader(HttpResponse res) {
Map<String, String> headerRes = new TreeMap<String, String>();
if (null == res) return headerRes;
// if (res.getStatusLine().getStatusCode() == 200) {//判断返回码，获取header信息
Header[] headers = res.getAllHeaders();
for (int i = 0; i < headers.length; i++) {
headerRes.put(headers[i].getName(), headers[i].getValue());
}
return headerRes;
}
private HttpHeaders headersFrom(HttpResponse httpResponse) {
return new HttpHeaders(
transform(
asList(httpResponse.getAllHeaders()),
new Function<Header, HttpHeader>() {
public HttpHeader apply(Header header) {
return new HttpHeader(header.getName(), header.getValue());
}
}));
}
private HttpResponse makeResponse(org.apache.http.HttpResponse hcResponse) throws IOException {
HttpResponseBuilder builder = new HttpResponseBuilder();
for (Header header : hcResponse.getAllHeaders()) {
builder.addHeader(header.getName(), header.getValue());
}
return builder
.setHttpStatusCode(hcResponse.getStatusLine().getStatusCode())
.setResponse(IOUtils.toByteArray(hcResponse.getEntity().getContent()))
.create();
}
public String renderResponseText(HttpResponse response) {
StringBuilder sb = new StringBuilder();
sb.append(renderResponseStartLine(response));
sb.append(renderHeaders(response.getAllHeaders()));
final String body = renderEntityIfAscii(response.getEntity());
if (body != null) {
sb.append("\n");
sb.append(body);
}
return sb.toString();
}
// Interface to AsyncHttpRequest
void sendResponseMessage(HttpResponse response) throws IOException {
// do not process if request has been cancelled
if (!Thread.currentThread().isInterrupted()) {
StatusLine status = response.getStatusLine();
byte[] responseBody;
responseBody = getResponseData(response.getEntity());
// additional cancellation check as getResponseData() can take non-zero time to process
if (!Thread.currentThread().isInterrupted()) {
if (status.getStatusCode() >= 300) {
sendFailureMessage(
status.getStatusCode(),
response.getAllHeaders(),
responseBody,
new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()));
} else {
sendSuccessMessage(status.getStatusCode(), response.getAllHeaders(), responseBody);
}
}
}
}
private static void logResponseHeaders(final HttpResponse response) {
if (!logger.isTraceEnabled()) {
return;
}
StringBuilder headers = new StringBuilder();
for (final Header header : response.getAllHeaders()) {
headers.append(header.getName()).append(": ").append(header.getValue()).append("\n");
}
logger.trace("Response headers:\n{}", headers);
}
/**
* deal with the response
*
* @param response
* @param clazz
* @return
* @throws IllegalStateException
* @throws ParseException
* @throws IOException
*/
private static String processResponse(HttpResponse response)
throws HttpResponseException, IllegalStateException, IOException {
int statusCode = response.getStatusLine().getStatusCode();
L.e("status--->code-->" + statusCode);
Header[] headers = response.getAllHeaders();
// if the return code is between 200 and 300. the request is success
if (HttpStatus.SC_OK <= statusCode && statusCode < HttpStatus.SC_MULTIPLE_CHOICES) {
return processEntity(response);
} else {
throw new HttpResponseException(statusCode, processEntity(response), headers);
}
}
@Test(
groups = {"wso2.am"},
description = "Checking CORS headers in response",
dependsOnMethods = "CheckCORSHeadersInPreFlightResponse")
public void CheckCORSHeadersInResponse() throws Exception {
HttpClient httpclient = HttpClientBuilder.create().build();
HttpGet get = new HttpGet(getAPIInvocationURLHttp(API_CONTEXT, API_VERSION));
get.addHeader("Origin", "http://localhost");
get.addHeader("Authorization", "Bearer " + accessToken);
HttpResponse response = httpclient.execute(get);
assertEquals(
response.getStatusLine().getStatusCode(), HTTP_RESPONSE_CODE_OK, "Response code mismatch.");
Header[] responseHeaders = response.getAllHeaders();
log.info("Response Headers: CheckCORSHeadersInResponse");
for (Header header : responseHeaders) {
log.info(header.getName() + " : " + header.getValue());
}
Header header = pickHeader(responseHeaders, ACCESS_CONTROL_ALLOW_ORIGIN_HEADER);
assertNotNull(
header, ACCESS_CONTROL_ALLOW_ORIGIN_HEADER + " header is not available in the response.");
assertEquals(
header.getValue(),
ACCESS_CONTROL_ALLOW_ORIGIN_HEADER_VALUE,
ACCESS_CONTROL_ALLOW_ORIGIN_HEADER + " header value mismatch.");
header = pickHeader(responseHeaders, ACCESS_CONTROL_ALLOW_METHODS_HEADER);
assertNotNull(
header, ACCESS_CONTROL_ALLOW_METHODS_HEADER + " header is not available in the response.");
assertEquals(
header.getValue(),
ACCESS_CONTROL_ALLOW_METHODS_HEADER_VALUE,
ACCESS_CONTROL_ALLOW_METHODS_HEADER + " header value mismatch.");
header = pickHeader(responseHeaders, ACCESS_CONTROL_ALLOW_HEADERS_HEADER);
assertNotNull(
header, ACCESS_CONTROL_ALLOW_HEADERS_HEADER + " header is not available in the response.");
assertEquals(
header.getValue(),
ACCESS_CONTROL_ALLOW_HEADERS_HEADER_VALUE,
ACCESS_CONTROL_ALLOW_HEADERS_HEADER + " header value mismatch.");
assertNull(
pickHeader(responseHeaders, ACCESS_CONTROL_ALLOW_CREDENTIALS_HEADER),
ACCESS_CONTROL_ALLOW_CREDENTIALS_HEADER
+ " header is available in the response, "
+ "but it should not be.");
}
/**
* @param response The response to parse
* @return A HttpResponse object made by consuming the response of the given HttpMethod.
* @throws IOException when problems occur processing the body content
*/
private HttpResponse makeResponse(org.apache.http.HttpResponse response) throws IOException {
HttpResponseBuilder builder = new HttpResponseBuilder();
if (response.getAllHeaders() != null) {
for (Header h : response.getAllHeaders()) {
if (h.getName() != null) builder.addHeader(h.getName(), h.getValue());
}
}
HttpEntity entity = response.getEntity();
if (maxObjSize > 0 && entity != null && entity.getContentLength() > maxObjSize) {
return HttpResponse.badrequest("Exceeded maximum number of bytes - " + maxObjSize);
}
byte[] responseBytes = (entity == null) ? null : toByteArraySafe(entity);
return builder
.setHttpStatusCode(response.getStatusLine().getStatusCode())
.setResponse(responseBytes)
.create();
}
private HttpResponse forward(
HttpClient httpclient,
String verb,
String uri,
HttpServletRequest request,
MultiValueMap<String, String> headers,
MultiValueMap<String, String> params,
InputStream requestEntity)
throws Exception {
Map<String, Object> info = this.helper.debug(verb, uri, headers, params, requestEntity);
URL host = RequestContext.getCurrentContext().getRouteHost();
HttpHost httpHost = getHttpHost(host);
uri = StringUtils.cleanPath(host.getPath() + uri);
HttpRequest httpRequest;
switch (verb.toUpperCase()) {
case "POST":
HttpPost httpPost = new HttpPost(uri + getQueryString());
httpRequest = httpPost;
httpPost.setEntity(new InputStreamEntity(requestEntity, request.getContentLength()));
break;
case "PUT":
HttpPut httpPut = new HttpPut(uri + getQueryString());
httpRequest = httpPut;
httpPut.setEntity(new InputStreamEntity(requestEntity, request.getContentLength()));
break;
case "PATCH":
HttpPatch httpPatch = new HttpPatch(uri + getQueryString());
httpRequest = httpPatch;
httpPatch.setEntity(new InputStreamEntity(requestEntity, request.getContentLength()));
break;
default:
httpRequest = new BasicHttpRequest(verb, uri + getQueryString());
log.debug(uri + getQueryString());
}
try {
httpRequest.setHeaders(convertHeaders(headers));
log.debug(httpHost.getHostName() + " " + httpHost.getPort() + " " + httpHost.getSchemeName());
HttpResponse zuulResponse = forwardRequest(httpclient, httpHost, httpRequest);
this.helper.appendDebug(
info,
zuulResponse.getStatusLine().getStatusCode(),
revertHeaders(zuulResponse.getAllHeaders()));
return zuulResponse;
} finally {
// When HttpClient instance is no longer needed,
// shut down the connection manager to ensure
// immediate deallocation of all system resources
// httpclient.getConnectionManager().shutdown();
}
}
private static void printDebugInfo(HttpUriRequest request, HttpResponse response) {
String br = System.getProperty("line.separator");
StringBuffer builder = new StringBuffer();
builder.append("URL: ");
builder.append(request.getURI().toString());
builder.append(br);
builder.append("Request Headers: ");
builder.append(headersToString(request.getAllHeaders()));
builder.append(br);
builder.append("Request Body: ");
if (request instanceof HttpPost) {
HttpPost post = (HttpPost) request;
String body = "This body can't be outputted.";
try {
body = ResponseUtil.fromHttpEntityToString(post.getEntity(), "UTF-8");
} catch (ResponseBodyParseException e) {
Log.d(TAG, "Parsing request is failed.", e);
}
builder.append(body);
} else {
builder.append("No body by Get request.");
}
builder.append(br);
builder.append("HTTP Status Code: ");
builder.append(response.getStatusLine().getStatusCode());
builder.append(br);
builder.append("Response Headers: ");
builder.append(headersToString(response.getAllHeaders()));
builder.append(br);
Header contentType = response.getFirstHeader("Content-Type");
if (contentType != null && "application/json".equals(contentType.getValue())) {
builder.append("Response Body: ");
String body = "This body can't be outputted.";
try {
body = ResponseUtil.fromHttpEntityToString(response.getEntity(), "UTF-8");
response.setEntity(new StringEntity(body, "UTF-8"));
} catch (ResponseBodyParseException e) {
Log.d(TAG, "Parsing response is failed.", e);
} catch (UnsupportedEncodingException e) {
Log.e(TAG, e.getMessage());
}
builder.append(body);
builder.append(br);
} else {
builder.append("Response Body is binary data.");
builder.append(br);
}
Log.d(TAG, builder.toString());
}
private void removeCacheHeadersThatMatchResponse(
List<Header> cacheEntryHeaderList, HttpResponse response) {
for (Header responseHeader : response.getAllHeaders()) {
ListIterator<Header> cacheEntryHeaderListIter = cacheEntryHeaderList.listIterator();
while (cacheEntryHeaderListIter.hasNext()) {
String cacheEntryHeaderName = cacheEntryHeaderListIter.next().getName();
if (cacheEntryHeaderName.equals(responseHeader.getName())) {
cacheEntryHeaderListIter.remove();
}
}
}
}
