private String signedRequest(
final Map<String, String> paramMap,
final Map<String, String> cookieMap,
final Map<String, String> headerMap,
final String apiPath)
throws IOException, ForbiddenException {
final String sessionId = cookieMap.get(SessionAttributeKeys.SESSION_ID);
if (StringUtils.isBlank(sessionId)) {
m_log.error(SessionAttributeKeys.SESSION_ID + " not in cookies: " + cookieMap);
throw new IOException("Missing session ID");
}
final String userId = cookieMap.get(SessionAttributeKeys.USER_ID);
if (StringUtils.isBlank(userId)) {
m_log.debug("No user ID!!");
// throw new IOException("Blank user ID");
} else {
paramMap.put("userId", userId);
}
m_log.debug("Sending session ID as cookie: " + sessionId);
final String baseUrl = createBaseUrl(apiPath);
final String finalUrl = sign(baseUrl, paramMap, cookieMap);
final HttpMethod method = new PostMethod(finalUrl);
method.setRequestHeader("Cookie", SessionAttributeKeys.SESSION_ID + "=" + sessionId);
if (headerMap.containsKey("Referer")) {
method.setRequestHeader("Referer", headerMap.get("Referer"));
}
m_log.debug("Sending request to: {}", finalUrl);
return post(method);
}
/**
* 发送http请求，并返回响应的xml报文 <功能详细描述>
*
* @param url http请求url
* @param xml 请求xml报文
* @return
*/
private String send(HttpMethod httpMethod) {
// 获取响应报文
String response = null;
int resultCode = HttpStatus.SC_OK;
try {
// 设置header信息，传输XML格式的
httpMethod.setRequestHeader(CONTENT_TYPE_NAME, CONTENT_TYPE_VALUE_XML_UTF_8);
// 处理响应结果码
resultCode = httpClient.executeMethod(httpMethod);
if (HttpStatus.SC_OK == resultCode) {
byte[] resBody = httpMethod.getResponseBody();
if (null != resBody && resBody.length > 0) {
response = new String(resBody, UTF_8);
}
} else {
response = resultCode + "";
LogUtil.error("Http response: " + httpMethod.getResponseBodyAsString());
}
} catch (Exception ex) {
response = ex.toString();
LogUtil.error("send http request error!", ex);
} finally {
if (null != httpMethod) {
httpMethod.releaseConnection();
}
}
return response;
}
/**
* Retreives all of the headers from the servlet request and sets them on the proxy request
*
* @param httpServletRequest The request object representing the client's request to the servlet
* engine
* @param httpMethodProxyRequest The request that we are about to send to the proxy host
*/
@SuppressWarnings("unchecked")
private void setProxyRequestHeaders(
HttpServletRequest httpServletRequest, HttpMethod httpMethodProxyRequest) {
// Get an Enumeration of all of the header names sent by the client
Enumeration enumerationOfHeaderNames = httpServletRequest.getHeaderNames();
while (enumerationOfHeaderNames.hasMoreElements()) {
String stringHeaderName = (String) enumerationOfHeaderNames.nextElement();
if (stringHeaderName.equalsIgnoreCase(STRING_CONTENT_LENGTH_HEADER_NAME)) continue;
// As per the Java Servlet API 2.5 documentation:
// Some headers, such as Accept-Language can be sent by clients
// as several headers each with a different value rather than
// sending the header as a comma separated list.
// Thus, we get an Enumeration of the header values sent by the client
Enumeration enumerationOfHeaderValues = httpServletRequest.getHeaders(stringHeaderName);
while (enumerationOfHeaderValues.hasMoreElements()) {
String stringHeaderValue = (String) enumerationOfHeaderValues.nextElement();
// In case the proxy host is running multiple virtual servers,
// rewrite the Host header to ensure that we get content from
// the correct virtual server
if (stringHeaderName.equalsIgnoreCase(STRING_HOST_HEADER_NAME)) {
stringHeaderValue = getProxyHostAndPort();
}
Header header = new Header(stringHeaderName, stringHeaderValue);
// Set the same header on the proxy request
httpMethodProxyRequest.setRequestHeader(header);
}
}
}
private String sendApp(HttpMethod httpMethod) {
String response = null;
int resultCode = HttpStatus.SC_OK;
try {
httpMethod.setRequestHeader(CONTENT_TYPE_NAME, CONTENT_TYPE_VALUE_XML_APP);
resultCode = httpClient.executeMethod(httpMethod);
if (HttpStatus.SC_OK == resultCode) {
byte[] resBody = httpMethod.getResponseBody();
if (null != resBody && resBody.length > 0) {
response = new String(resBody, UTF_8);
}
} else {
response = "ResultCode = " + resultCode;
}
} catch (Exception ex) {
response = ex.toString();
} finally {
if (null != httpMethod) {
httpMethod.releaseConnection();
}
}
return response;
}
/**
* If a 'Proxy-Connection' header has been added to the request, it'll be of a 'keep-alive' type.
* Until we support 'keep-alives', override the Proxy-Connection setting and instead pass a
* 'close' (Otherwise every request has to timeout before we notice end-of-document).
*
* @param method Method to find proxy-connection header in.
*/
public void handleAddProxyConnectionHeader(HttpMethod method) {
Header h = method.getRequestHeader("Proxy-Connection");
if (h != null) {
h.setValue("close");
method.setRequestHeader(h);
}
}
private void writeOutBoundHeaders(MultivaluedMap<String, Object> metadata, HttpMethod method) {
for (Map.Entry<String, List<Object>> e : metadata.entrySet()) {
List<Object> vs = e.getValue();
if (vs.size() == 1) {
method.setRequestHeader(e.getKey(), headerValueToString(vs.get(0)));
} else {
StringBuilder b = new StringBuilder();
for (Object v : e.getValue()) {
if (b.length() > 0) {
b.append(',');
}
b.append(headerValueToString(v));
}
method.setRequestHeader(e.getKey(), b.toString());
}
}
}
/**
* Gets the result of the execution of a get request. the attempt will be repeated until obtain
* the exepected result
*
* @param path the path on which the request should be executed
* @param expression the result that should be returned by the GET request, which allows to know
* if that request is completely processed or not
* @throws Exception if something's going wrong...
*/
public void retryGetRequestUntilObtainExpectedResponse(
@NonNull String path, @NonNull String expression) throws Exception {
String fullpath = path;
if (path.startsWith("/")) fullpath = baseUrl + path;
log.debug("Sending GET request to " + fullpath + " with several attemps");
final int maxAttempts = Integer.parseInt(ExecutionContext.get(RestConstants.MAX_ATTEMPTS_KEY));
final int timeToWait = Integer.parseInt(ExecutionContext.get(RestConstants.TIME_TO_WAIT_KEY));
final HttpMethod method = new GetMethod(fullpath);
try {
for (final Map.Entry<String, String> header : requestHeaders.entrySet())
method.setRequestHeader(header.getKey(), header.getValue());
String responseAsString = null;
String toCheck = null;
String expected = expression;
String prop = null;
final int idx = expression.indexOf("=");
if (idx > 0) {
prop = expression.substring(0, idx);
expected = expression.substring(idx + 1);
}
int statusCode;
int attempts = 0;
boolean success = false;
do {
// waiting timeToWait seconds
Thread.sleep(timeToWait * 1000);
statusCode = httpClient.executeMethod(method);
attempts++;
if (statusCode == HttpStatus.SC_OK) {
responseAsString = method.getResponseBodyAsString();
toCheck = responseAsString;
if (prop != null) toCheck = JSONHelper.getPropertyValue(responseAsString, prop);
if (toCheck.contains(expected)) {
success = true;
log.debug("The result is available! ");
} else
log.warn("The result is not yet available! | Waiting " + timeToWait + " seconds ...");
} else
log.warn(
"unsuccessful GET request : "
+ method.getStatusLine()
+ " | Waiting "
+ timeToWait
+ " seconds ...");
} while (!success && maxAttempts > attempts);
response = new ResponseWrapper(responseAsString, statusCode);
} catch (final Exception e) {
log.error(e.getMessage(), e);
throw e;
} finally {
method.releaseConnection();
}
}
public HttpMethod generateRequestFor(List<String> recipients, String message) {
HttpMethod httpMethod;
if (HttpMethodType.POST.equals(outgoing.getRequest().getType())) {
httpMethod = new PostMethod(outgoing.getRequest().getUrlPath());
httpMethod.setRequestHeader("Content-Type", PostMethod.FORM_URL_ENCODED_CONTENT_TYPE);
addBodyParameters((PostMethod) httpMethod, recipients, message);
} else {
httpMethod = new GetMethod(outgoing.getRequest().getUrlPath());
}
httpMethod.setQueryString(addQueryParameters(recipients, message));
return httpMethod;
}
protected void setHttpRequestHeader(HttpMethod method) {
method.setRequestHeader(
"Accept",
"text/html,application/xhtml+xml,application/xml,application/json,image/jpeg,image/gif,*/*");
method.setRequestHeader("Accept-Language", "zh-cn");
method.setRequestHeader(
"User-Agent",
"Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3");
method.setRequestHeader("Accept-Charset", encoding);
method.setRequestHeader("Keep-Alive", "300");
method.setRequestHeader("Connection", "Keep-Alive");
method.setRequestHeader("Cache-Control", "no-cache");
}
private HttpMethod createMethod(HttpMethodEnum httpMethodEnum, String url, HttpData httpData) {
HttpMethod method = null;
if (httpMethodEnum == HttpMethodEnum.GET) {
method = this.createGetMethod(url);
} else if (httpMethodEnum == HttpMethodEnum.POST) {
method = this.createPostMethod(url, httpData);
} else {
method = this.createMultiPostMethod(url, httpData);
}
if (httpData != null) {
if (httpData.getHttpHeader() != null) {
method.setRequestHeader(
httpData.getHttpHeader().getName(), httpData.getHttpHeader().getValue());
}
}
return method;
}
private int patchRedirection(int status, HttpMethod method) throws HttpException, IOException {
int redirectionsCount = 0;
while (redirectionsCount < MAX_REDIRECTIONS_COUNT
&& (status == HttpStatus.SC_MOVED_PERMANENTLY
|| status == HttpStatus.SC_MOVED_TEMPORARILY
|| status == HttpStatus.SC_TEMPORARY_REDIRECT)) {
Header location = method.getResponseHeader("Location");
if (location == null) {
location = method.getResponseHeader("location");
}
if (location != null) {
Log_OC.d(TAG + " #" + mInstanceNumber, "Location to redirect: " + location.getValue());
method.setURI(new URI(location.getValue(), true));
Header destination = method.getRequestHeader("Destination");
if (destination == null) {
destination = method.getRequestHeader("destination");
}
if (destination != null) {
String locationStr = location.getValue();
int suffixIndex =
locationStr.lastIndexOf(
(mCredentials instanceof OwnCloudBearerCredentials)
? AccountUtils.ODAV_PATH
: AccountUtils.WEBDAV_PATH_4_0);
String redirectionBase = locationStr.substring(0, suffixIndex);
String destinationStr = destination.getValue();
String destinationPath = destinationStr.substring(mBaseUri.toString().length());
String redirectedDestination = redirectionBase + destinationPath;
destination.setValue(redirectedDestination);
method.setRequestHeader(destination);
}
status = super.executeMethod(method);
redirectionsCount++;
} else {
Log_OC.d(TAG + " #" + mInstanceNumber, "No location to redirect!");
status = HttpStatus.SC_NOT_FOUND;
}
}
return status;
}
/**
* Gets the result of the execution of a get request. the attempt will be repeated several times
* in case of failures
*
* @param path the path on which the request should be sent
* @throws Exception if something's going wrong...
*/
public void retryGetRequestUntilSucceed(@NonNull String path) throws Exception {
String fullpath = path;
if (path.startsWith("/")) fullpath = baseUrl + path;
log.debug("Sending GET request to " + fullpath + " with several attemps");
final int maxAttempts = Integer.parseInt(ExecutionContext.get(RestConstants.MAX_ATTEMPTS_KEY));
final int timeToWait = Integer.parseInt(ExecutionContext.get(RestConstants.TIME_TO_WAIT_KEY));
final HttpMethod method = new GetMethod(fullpath);
try {
for (final Map.Entry<String, String> header : requestHeaders.entrySet())
method.setRequestHeader(header.getKey(), header.getValue());
String responseAsString = null;
int statusCode;
int attempts = 0;
boolean success = false;
do {
// waiting timeToWait seconds
Thread.sleep(timeToWait * 1000);
statusCode = httpClient.executeMethod(method);
attempts++;
// check for status code 200
if (statusCode == HttpStatus.SC_OK) {
responseAsString = method.getResponseBodyAsString();
success = true;
log.info("The result is available! ");
} else
log.warn(
"unsuccessful GET request : "
+ method.getStatusLine()
+ " | Waiting "
+ timeToWait
+ " seconds ...");
} while (!success && maxAttempts > attempts);
response = new ResponseWrapper(responseAsString, statusCode);
} catch (final Exception e) {
log.error(e.getMessage(), e);
throw e;
} finally {
method.releaseConnection();
}
}
/**
* Allows to send a GET request to the path passed using the http client
*
* @param path the path on which the request should be sent
*/
public void sendGetRequest(final String path) throws Exception {
String fullpath = path;
if (path.startsWith("/")) fullpath = baseUrl + path;
log.info("Sending GET request to " + fullpath);
final HttpMethod method = new GetMethod(fullpath);
try {
for (final Map.Entry<String, String> header : requestHeaders.entrySet())
method.setRequestHeader(header.getKey(), header.getValue());
final int statusCode = httpClient.executeMethod(method);
response =
new ResponseWrapper(
method.getResponseBodyAsString(), method.getResponseHeaders(), statusCode);
} catch (final IOException e) {
log.error(e.getMessage(), e);
throw e;
} finally {
method.releaseConnection();
}
}
private String post(final HttpMethod method) throws IOException, ForbiddenException {
method.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
method.setRequestHeader("Accept-Encoding", "gzip");
InputStream is = null;
try {
this.m_clientManager.executeMethod(method);
final int statusCode = method.getStatusCode();
final StatusLine statusLine = method.getStatusLine();
final Header encoding = method.getResponseHeader("Content-Encoding");
if (encoding != null && encoding.getValue().equals("gzip")) {
m_log.debug("Unzipping body...");
is = new GZIPInputStream(method.getResponseBodyAsStream());
} else {
is = method.getResponseBodyAsStream();
}
final String body = IOUtils.toString(is);
if (StringUtils.isBlank(body)) {
// Could easily be a post request, which would not have a body.
m_log.debug("No response body. Post request?");
}
if (statusCode == HttpStatus.SC_FORBIDDEN) {
final String msg = "NO 200 OK: " + method.getURI() + "\n" + statusLine + "\n" + body;
m_log.warn(msg);
throw new ForbiddenException(msg);
}
if (statusCode != HttpStatus.SC_OK) {
final String msg = "NO 200 OK: " + method.getURI() + "\n" + statusLine + "\n" + body;
m_log.warn(msg);
throw new IOException(msg);
} else {
m_log.debug("Got 200 response...");
}
return body;
} finally {
IOUtils.closeQuietly(is);
method.releaseConnection();
}
}
public JSONObject get(String path) throws Exception {
JSONObject result;
HttpMethod method = new GetMethod(repoHostname + ":" + repoHostPort + "/api/data/" + path);
method.getParams().setCookiePolicy(CookiePolicy.RFC_2109);
method.setRequestHeader("Cookie", "jsonhub-store-key=" + getStoreKey());
// client.getState().setCredentials(new AuthScope(null, repoHostPort, "authentication"), new
// UsernamePasswordCredentials(memberId, memberPassword));
// method.setDoAuthentication(true);
int statusCode = client.executeMethod(method);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: " + method.getStatusLine());
throw new GeneralException(method.getStatusLine().toString());
} else {
Reader reader = new InputStreamReader(method.getResponseBodyAsStream());
CharArrayWriter cdata = new CharArrayWriter();
char buf[] = new char[BUFFER_SIZE];
int ret;
while ((ret = reader.read(buf, 0, BUFFER_SIZE)) != -1) cdata.write(buf, 0, ret);
reader.close();
System.out.println("get response: " + cdata.toString());
result = JSONObject.fromObject(cdata.toString());
}
method.releaseConnection();
if (result.has("error")) throw new GeneralException(result.getString("error"));
return result;
}
/**
* Sets a header to notify server we expect a JSON-repsponse for this method.
*
* @param method
*/
public static void setJSONExpected(HttpMethod method) {
method.setRequestHeader(HEADER_ACCEPT, MIME_TYPE_JSON);
}
protected void applyRequestHeaders(HttpMethod method) {
for (String name : requestHeaders.keySet()) {
String value = requestHeaders.get(name);
method.setRequestHeader(name, value);
}
}
/**
* Makes a rest request of any type at the specified urlSuffix. The urlSuffix should be of the
* form /userService/users. If CS throws an exception it handled and transalated to a Openfire
* exception if possible. This is done using the check fault method that tries to throw the best
* maching exception.
*
* @param type Must be GET or DELETE
* @param urlSuffix The url suffix of the rest request
* @param xmlParams The xml with the request params, must be null if type is GET or DELETE only
* @return The response as a xml doc.
* @throws ConnectionException Thrown if there are issues perfoming the request.
* @throws Exception Thrown if the response from Clearspace contains an exception.
*/
public Element executeRequest(HttpType type, String urlSuffix, String xmlParams)
throws ConnectionException, Exception {
if (Log.isDebugEnabled()) {
Log.debug("Outgoing REST call [" + type + "] to " + urlSuffix + ": " + xmlParams);
}
String wsUrl = getConnectionURI() + WEBSERVICES_PATH + urlSuffix;
String secret = getSharedSecret();
HttpClient client = new HttpClient();
HttpMethod method;
// Configures the authentication
client.getParams().setAuthenticationPreemptive(true);
Credentials credentials = new UsernamePasswordCredentials(OPENFIRE_USERNAME, secret);
AuthScope scope = new AuthScope(host, port, AuthScope.ANY_REALM);
client.getState().setCredentials(scope, credentials);
// Creates the method
switch (type) {
case GET:
method = new GetMethod(wsUrl);
break;
case POST:
PostMethod pm = new PostMethod(wsUrl);
StringRequestEntity requestEntity = new StringRequestEntity(xmlParams);
pm.setRequestEntity(requestEntity);
method = pm;
break;
case PUT:
PutMethod pm1 = new PutMethod(wsUrl);
StringRequestEntity requestEntity1 = new StringRequestEntity(xmlParams);
pm1.setRequestEntity(requestEntity1);
method = pm1;
break;
case DELETE:
method = new DeleteMethod(wsUrl);
break;
default:
throw new IllegalArgumentException();
}
method.setRequestHeader("Accept", "text/xml");
method.setDoAuthentication(true);
try {
// Executes the request
client.executeMethod(method);
// Parses the result
String body = method.getResponseBodyAsString();
if (Log.isDebugEnabled()) {
Log.debug("Outgoing REST call results: " + body);
}
// Checks the http status
if (method.getStatusCode() != 200) {
if (method.getStatusCode() == 401) {
throw new ConnectionException(
"Invalid password to connect to Clearspace.",
ConnectionException.ErrorType.AUTHENTICATION);
} else if (method.getStatusCode() == 404) {
throw new ConnectionException(
"Web service not found in Clearspace.", ConnectionException.ErrorType.PAGE_NOT_FOUND);
} else if (method.getStatusCode() == 503) {
throw new ConnectionException(
"Web service not avaible in Clearspace.",
ConnectionException.ErrorType.SERVICE_NOT_AVAIBLE);
} else {
throw new ConnectionException(
"Error connecting to Clearspace, http status code: " + method.getStatusCode(),
new HTTPConnectionException(method.getStatusCode()),
ConnectionException.ErrorType.OTHER);
}
} else if (body.contains("Clearspace Upgrade Console")) {
// TODO Change CS to send a more standard error message
throw new ConnectionException(
"Clearspace is in an update state.", ConnectionException.ErrorType.UPDATE_STATE);
}
Element response = localParser.get().parseDocument(body).getRootElement();
// Check for exceptions
checkFault(response);
// Since there is no exception, returns the response
return response;
} catch (DocumentException e) {
throw new ConnectionException(
"Error parsing the response of Clearspace.", e, ConnectionException.ErrorType.OTHER);
} catch (HttpException e) {
throw new ConnectionException(
"Error performing http request to Clearspace", e, ConnectionException.ErrorType.OTHER);
} catch (UnknownHostException e) {
throw new ConnectionException(
"Unknown Host " + getConnectionURI() + " trying to connect to Clearspace",
e,
ConnectionException.ErrorType.UNKNOWN_HOST);
} catch (IOException e) {
throw new ConnectionException(
"Error peforming http request to Clearspace.", e, ConnectionException.ErrorType.OTHER);
} finally {
method.releaseConnection();
}
}
public NamedList<Object> request(final SolrRequest request, ResponseParser processor)
throws SolrServerException, IOException {
HttpMethod method = null;
InputStream is = null;
SolrParams params = request.getParams();
Collection<ContentStream> streams = requestWriter.getContentStreams(request);
String path = requestWriter.getPath(request);
if (path == null || !path.startsWith("/")) {
path = "/select";
}
ResponseParser parser = request.getResponseParser();
if (parser == null) {
parser = _parser;
}
// The parser 'wt=' and 'version=' params are used instead of the original params
ModifiableSolrParams wparams = new ModifiableSolrParams();
wparams.set(CommonParams.WT, parser.getWriterType());
wparams.set(CommonParams.VERSION, parser.getVersion());
if (params == null) {
params = wparams;
} else {
params = new DefaultSolrParams(wparams, params);
}
if (_invariantParams != null) {
params = new DefaultSolrParams(_invariantParams, params);
}
int tries = _maxRetries + 1;
try {
while (tries-- > 0) {
// Note: since we aren't do intermittent time keeping
// ourselves, the potential non-timeout latency could be as
// much as tries-times (plus scheduling effects) the given
// timeAllowed.
try {
if (SolrRequest.METHOD.GET == request.getMethod()) {
if (streams != null) {
throw new SolrException(
SolrException.ErrorCode.BAD_REQUEST, "GET can't send streams!");
}
method = new GetMethod(_baseURL + path + ClientUtils.toQueryString(params, false));
} else if (SolrRequest.METHOD.POST == request.getMethod()) {
String url = _baseURL + path;
boolean isMultipart = (streams != null && streams.size() > 1);
if (streams == null || isMultipart) {
PostMethod post = new PostMethod(url);
post.getParams().setContentCharset("UTF-8");
if (!this.useMultiPartPost && !isMultipart) {
post.addRequestHeader(
"Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
}
List<Part> parts = new LinkedList<Part>();
Iterator<String> iter = params.getParameterNamesIterator();
while (iter.hasNext()) {
String p = iter.next();
String[] vals = params.getParams(p);
if (vals != null) {
for (String v : vals) {
if (this.useMultiPartPost || isMultipart) {
parts.add(new StringPart(p, v, "UTF-8"));
} else {
post.addParameter(p, v);
}
}
}
}
if (isMultipart) {
int i = 0;
for (ContentStream content : streams) {
final ContentStream c = content;
String charSet = null;
String transferEncoding = null;
parts.add(
new PartBase(c.getName(), c.getContentType(), charSet, transferEncoding) {
@Override
protected long lengthOfData() throws IOException {
return c.getSize();
}
@Override
protected void sendData(OutputStream out) throws IOException {
InputStream in = c.getStream();
try {
IOUtils.copy(in, out);
} finally {
in.close();
}
}
});
}
}
if (parts.size() > 0) {
post.setRequestEntity(
new MultipartRequestEntity(
parts.toArray(new Part[parts.size()]), post.getParams()));
}
method = post;
}
// It is has one stream, it is the post body, put the params in the URL
else {
String pstr = ClientUtils.toQueryString(params, false);
PostMethod post = new PostMethod(url + pstr);
// Single stream as body
// Using a loop just to get the first one
final ContentStream[] contentStream = new ContentStream[1];
for (ContentStream content : streams) {
contentStream[0] = content;
break;
}
if (contentStream[0] instanceof RequestWriter.LazyContentStream) {
post.setRequestEntity(
new RequestEntity() {
public long getContentLength() {
return -1;
}
public String getContentType() {
return contentStream[0].getContentType();
}
public boolean isRepeatable() {
return false;
}
public void writeRequest(OutputStream outputStream) throws IOException {
((RequestWriter.LazyContentStream) contentStream[0]).writeTo(outputStream);
}
});
} else {
is = contentStream[0].getStream();
post.setRequestEntity(
new InputStreamRequestEntity(is, contentStream[0].getContentType()));
}
method = post;
}
} else {
throw new SolrServerException("Unsupported method: " + request.getMethod());
}
} catch (NoHttpResponseException r) {
// This is generally safe to retry on
method.releaseConnection();
method = null;
if (is != null) {
is.close();
}
// If out of tries then just rethrow (as normal error).
if ((tries < 1)) {
throw r;
}
// log.warn( "Caught: " + r + ". Retrying..." );
}
}
} catch (IOException ex) {
throw new SolrServerException("error reading streams", ex);
}
method.setFollowRedirects(_followRedirects);
method.addRequestHeader("User-Agent", AGENT);
if (_allowCompression) {
method.setRequestHeader(new Header("Accept-Encoding", "gzip,deflate"));
}
try {
// Execute the method.
// System.out.println( "EXECUTE:"+method.getURI() );
int statusCode = _httpClient.executeMethod(method);
if (statusCode != HttpStatus.SC_OK) {
StringBuilder msg = new StringBuilder();
msg.append(method.getStatusLine().getReasonPhrase());
msg.append("\n\n");
msg.append(method.getStatusText());
msg.append("\n\n");
msg.append("request: " + method.getURI());
throw new SolrException(statusCode, java.net.URLDecoder.decode(msg.toString(), "UTF-8"));
}
// Read the contents
String charset = "UTF-8";
if (method instanceof HttpMethodBase) {
charset = ((HttpMethodBase) method).getResponseCharSet();
}
InputStream respBody = method.getResponseBodyAsStream();
// Jakarta Commons HTTPClient doesn't handle any
// compression natively. Handle gzip or deflate
// here if applicable.
if (_allowCompression) {
Header contentEncodingHeader = method.getResponseHeader("Content-Encoding");
if (contentEncodingHeader != null) {
String contentEncoding = contentEncodingHeader.getValue();
if (contentEncoding.contains("gzip")) {
// log.debug( "wrapping response in GZIPInputStream" );
respBody = new GZIPInputStream(respBody);
} else if (contentEncoding.contains("deflate")) {
// log.debug( "wrapping response in InflaterInputStream" );
respBody = new InflaterInputStream(respBody);
}
} else {
Header contentTypeHeader = method.getResponseHeader("Content-Type");
if (contentTypeHeader != null) {
String contentType = contentTypeHeader.getValue();
if (contentType != null) {
if (contentType.startsWith("application/x-gzip-compressed")) {
// log.debug( "wrapping response in GZIPInputStream" );
respBody = new GZIPInputStream(respBody);
} else if (contentType.startsWith("application/x-deflate")) {
// log.debug( "wrapping response in InflaterInputStream" );
respBody = new InflaterInputStream(respBody);
}
}
}
}
}
return processor.processResponse(respBody, charset);
} catch (HttpException e) {
throw new SolrServerException(e);
} catch (IOException e) {
throw new SolrServerException(e);
} finally {
method.releaseConnection();
if (is != null) {
is.close();
}
}
}