private void writeLinks(HttpRequestBase httpMethod, String basePath) {
StringBuilder linkHeader = new StringBuilder();
for (RiakLink link : this.links) {
if (linkHeader.length() > 0) {
linkHeader.append(", ");
}
linkHeader.append("<");
linkHeader.append(basePath);
linkHeader.append("/");
linkHeader.append(link.getBucket());
linkHeader.append("/");
linkHeader.append(link.getKey());
linkHeader.append(">; ");
linkHeader.append(Constants.LINK_TAG);
linkHeader.append("=\"");
linkHeader.append(link.getTag());
linkHeader.append("\"");
// To avoid (MochiWeb) problems with too long headers, flush if
// it grows too big:
if (linkHeader.length() > 2000) {
httpMethod.addHeader(Constants.HDR_LINK, linkHeader.toString());
linkHeader = new StringBuilder();
}
}
if (linkHeader.length() > 0) {
httpMethod.addHeader(Constants.HDR_LINK, linkHeader.toString());
}
}
private static ArrayList<SearchResults> apiRequest(
String endpoint, String methodName, Map<String, String> params, File file)
throws IOException, JSONException {
HttpClient client = new DefaultHttpClient();
HttpRequestBase request = null;
String url = null;
if (endpoint.startsWith("http")) {
url = endpoint;
} else {
url = new StringBuffer(VIMEO_SERVER).append(endpoint).toString();
}
if (methodName.equals(HttpGet.METHOD_NAME)) {
request = new HttpGet(url);
} else if (methodName.equals(HttpPost.METHOD_NAME)) {
request = new HttpPost(url);
}
request.addHeader("Accept", "application/vnd.vimeo.*+json; version=3.2");
request.addHeader(
"Authorization", new StringBuffer(tokenType).append(" ").append(token).toString());
HttpResponse response = client.execute(request);
String responseAsString = null;
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != 204) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
response.getEntity().writeTo(out);
responseAsString = out.toString("UTF-8");
out.close();
}
JSONObject json = null;
try {
json = new JSONObject(responseAsString);
} catch (Exception e) {
json = new JSONObject();
}
ArrayList<SearchResults> tempSearch = new ArrayList<SearchResults>();
for (int i = 0; i < json.getJSONArray("data").length(); i++) {
JSONObject object = (JSONObject) json.getJSONArray("data").get(i);
Map<String, String> out = new HashMap<String, String>();
parse(object, out);
SearchResults temp = new SearchResults();
temp.setTitle(out.get("name"));
// temp.setOwner("By: " + out.get("owner.screenname"));
temp.setId(out.get("uri").substring(out.get("uri").lastIndexOf('/') + 1));
JSONArray tJson = new JSONArray(out.get("sizes"));
for (int j = 0; j < tJson.length(); j++) {
parse((JSONObject) tJson.get(j), out);
if (out.get("width").equals("200")) {
temp.setThumbnailUrl(out.get("link"));
break;
}
}
temp.setProvider("Vimeo");
tempSearch.add(temp);
}
return tempSearch;
}
public void addRequestHeaders(NativeObject headersNO) {
if (headersNO != null) {
for (Object o : headersNO.getAllIds()) {
Object val = headersNO.get(o.toString(), null);
if (val instanceof NativeArray) {
NativeArray arr = (NativeArray) val;
for (int i = 0; i < arr.getLength(); i++) {
method.addHeader(o.toString(), arr.get(i, null).toString());
}
} else {
method.addHeader(o.toString(), val.toString());
}
}
}
}
private Response doRequest(final Request<?> request, final HttpRequestBase fetcher) {
if (fetcher == null) {
return null;
}
List<Parameter> headers = request.getHeaders();
if (checkListOfParams(headers)) {
for (Parameter parameter : headers) {
Header header = new BasicHeader(parameter.getName(), parameter.getValue());
fetcher.addHeader(header);
}
}
final DefaultHttpClient httpClient = getHttpClient();
List<Parameter> cookies = request.getCookies();
if (checkListOfParams(cookies)) {
CookieStore cookieStore = httpClient.getCookieStore();
for (Parameter cookie : cookies) {
cookieStore.addCookie(new BasicClientCookie(cookie.getName(), cookie.getValue()));
}
httpClient.setCookieStore(cookieStore);
}
return doRequest(fetcher, httpClient);
}
@Override
public void onCheckRequestHeaders(String requestUrl, HttpRequestBase request) {
if (request == null) {
throw new IllegalArgumentException("Http Request is null");
}
if (SUPPORT_RANGED) {
// 目前只有大文件下载才会做此接口回调，在此回调中可以增加断点续传
if (request instanceof HttpGet) {
String saveFile =
mDownloadFilenameCreateListener != null
? mDownloadFilenameCreateListener.onFilenameCreateWithDownloadUrl(requestUrl)
: mDefaultDownloadFilenameCreateListener.onFilenameCreateWithDownloadUrl(
requestUrl);
File bigCacheFile = new File(INPUT_STREAM_CACHE_PATH);
if (!bigCacheFile.exists() || !bigCacheFile.isDirectory()) {
bigCacheFile.delete();
bigCacheFile.mkdirs();
}
File tempFile = new File(INPUT_STREAM_CACHE_PATH + saveFile);
long fileSize = 0;
if (tempFile.exists()) {
fileSize = tempFile.length();
} else {
fileSize = 0;
}
request.addHeader("RANGE", "bytes=" + fileSize + "-");
}
}
}
private void addHeaders(HttpClientRequest request, HttpRequestBase baseRequest) {
ScopedAttributesResolutionStrategy attributes =
request.getAttributes().getScopeAttributeContext(ContextScope.REQUEST_HEADERS);
for (Attribute attribute : attributes) {
baseRequest.addHeader(attribute.getName(), attribute.getValue(String.class));
}
}
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;
}
/**
* Write HTTP header for each secondary index
*
* @param httpMethod
*/
@SuppressWarnings("rawtypes")
private void writeIndexes(HttpRequestBase httpMethod) {
// write 2i headers
synchronized (indexLock) {
for (RiakIndex i : indexes) {
String index = i.getName();
httpMethod.addHeader(Constants.HDR_SEC_INDEX_REQ_PREFIX + index, i.getValue().toString());
}
}
}
public void commitHeaders(ClientRequest request, HttpRequestBase httpMethod) {
MultivaluedMap<String, String> headers = request.getHeaders();
for (Map.Entry<String, List<String>> header : headers.entrySet()) {
List<String> values = header.getValue();
for (String value : values) {
// System.out.println(String.format("setting %s = %s", header.getKey(),
// value));
httpMethod.addHeader(header.getKey(), value);
}
}
}
public HttpOperation(HttpOperationClient httpoperationclient, HttpRequestBase httprequestbase, HttpOperationReader httpoperationreader, VineAPI vineapi)
{
httprequestbase.addHeader("Accept-Encoding", "gzip");
httprequestbase.addHeader("User-Agent", USER_AGENT_STRING);
if (vineapi != null)
{
vineapi.addClientHeaders(httprequestbase);
}
mHttpClient = httpoperationclient.getHttpClient();
mHttpRequest = httprequestbase;
if (httpoperationreader == null)
{
mReader = DEFAULT_READER;
return;
} else
{
mReader = httpoperationreader;
return;
}
}
/**
* Serializes this object to an existing {@link HttpRequestBase} which can be sent as an HTTP
* request. Specifically, sends the object's link, user-defined metadata and vclock as HTTP
* headers and the value as the body. Used by {@link RiakClient} to create PUT requests.
*
* <p>if the this RiakObject's value is a stream, and no length is set, the stream is first
* buffered into a byte array before being written
*/
public void writeToHttpMethod(HttpRequestBase httpMethod) {
// Serialize headers
String basePath = getBasePathFromHttpMethod(httpMethod);
writeLinks(httpMethod, basePath);
for (String name : userMetaData.keySet()) {
httpMethod.addHeader(Constants.HDR_USERMETA_REQ_PREFIX + name, userMetaData.get(name));
}
writeIndexes(httpMethod);
if (vclock != null) {
httpMethod.addHeader(Constants.HDR_VCLOCK, vclock);
}
// Serialize body
if (httpMethod instanceof HttpEntityEnclosingRequestBase) {
HttpEntityEnclosingRequestBase entityEnclosingMethod =
(HttpEntityEnclosingRequestBase) httpMethod;
AbstractHttpEntity entity = null;
// Any value set using setValueAsStream() has precedent over value
// set using setValue()
if (valueStream != null) {
if (valueStreamLength != null && valueStreamLength >= 0) {
entity = new InputStreamEntity(valueStream, valueStreamLength);
} else {
// since apache http client 4.1 no longer supports buffering stream entities, but we can't
// change API
// behaviour, here we have to buffer the whole content
entity = new ByteArrayEntity(ClientUtils.bufferStream(valueStream));
}
} else if (value != null) {
entity = new ByteArrayEntity(value);
} else {
entity = new ByteArrayEntity(EMPTY);
}
entity.setContentType(contentType);
entityEnclosingMethod.setEntity(entity);
}
}
private JSONObject fastRequestHelper(HttpRequestBase request)
throws IOException, org.json.simple.parser.ParseException {
request.addHeader("authToken", authToken);
request.addHeader("requestToken", requestToken);
request.addHeader("appKey", penguinAppId);
HttpResponse response = httpclient.execute(request, localContext);
HttpEntity entity = response.getEntity();
InputStreamReader in =
zip
? new InputStreamReader(new GZIPInputStream(entity.getContent()))
: new InputStreamReader(entity.getContent());
Object result;
synchronized (jsonParser) { // Parser is not thread safe!
result = jsonParser.parse(in);
}
System.out.println("fastRequest" + (JSONObject) result);
return (JSONObject) result;
}
protected void addHeaders(HttpHeaders headers, HttpRequestBase uriRequest) {
if (headers == null) {
headers = new HttpHeaders();
}
// Add default accept headers
if (!headers.containsKey(HttpHeaders.ACCEPT)) {
headers.set(HttpHeaders.ACCEPT, "*/*");
}
// Add default user agent
if (!headers.containsKey(HttpHeaders.USER_AGENT)) {
headers.set(HttpHeaders.USER_AGENT, "apache/httpclient4");
}
for (Iterator<Entry<String, List<String>>> headerIterator = headers.entrySet().iterator();
headerIterator.hasNext(); ) {
Entry<String, List<String>> header = headerIterator.next();
if (HttpHeaders.COOKIE.equalsIgnoreCase(header.getKey())) {
uriRequest.addHeader(header.getKey(), StringUtil.join(header.getValue(), ';'));
} else {
for (String headerValue : header.getValue()) {
uriRequest.addHeader(header.getKey(), headerValue != null ? headerValue : "");
}
}
}
}
/**
* Copy header values from source request to the http method.
*
* @param method
*/
private void setHeaders(HttpRequestBase method) {
final Enumeration<String> headerNames = sourceRequest.getHeaderNames();
while (headerNames.hasMoreElements()) {
final String headerName = headerNames.nextElement();
if (excludeHeader(headerName)) {
continue;
}
final Enumeration<String> headerValues = sourceRequest.getHeaders(headerName);
while (headerValues.hasMoreElements()) {
String headerValue = headerValues.nextElement();
method.addHeader(headerName, processHeaderValue(headerName, headerValue));
}
}
}
/**
* @param request
* @return
*/
private HttpClientResponse execute(HttpRequestBase request) throws HttpProcessException {
try {
// add user agent
request.addHeader("User-Agent", createUserAgentHeaderValue());
final HttpResponse apacheResponse = apacheClient.execute(request);
return new HttpClientResponseAdapter(apacheResponse);
} catch (ClientProtocolException e) {
throw new HttpProtocolException(e);
} catch (IOException e) {
throw new HttpProtocolException(ManagedIOException.manage(e));
}
}
// create http request
private HttpRequestBase getHttpRequest() {
HttpRequestBase httpRequest = null;
if (method == null) {
method = RestMethod.GET;
}
// set method
switch (method) {
case GET:
httpRequest = new HttpGet(getFinalURL().toString());
break;
case DELETE:
httpRequest = new HttpDelete(getFinalURL().toString());
break;
case POST:
HttpPost postRequest = new HttpPost(getFinalURL().toString());
if (multipartEntity != null) {
postRequest.setEntity(multipartEntity);
} else {
postRequest.setEntity(getBody());
}
httpRequest = postRequest;
break;
case PUT:
HttpPut putRequest = new HttpPut(getFinalURL().toString());
putRequest.setEntity(getBody());
httpRequest = putRequest;
break;
default:
break;
}
// set headers
if (headers != null) {
for (String key : headers.keySet()) {
httpRequest.addHeader(key, headers.get(key));
}
}
return httpRequest;
}
@Override
public Response execute(Request request) {
if (!(request instanceof HttpRemoteRequest)) {
throw new IllegalArgumentException("必须是HttpRequest才能执行！，参数是：" + request);
}
try {
// 添加用户来源标记
request.addParameter("userRefer", 1);
HttpRemoteRequest httpRequest = (HttpRemoteRequest) request;
HttpRequestBase httpRequestBase = asHttpRequest(httpRequest);
String sessionId = request.getSessionId();
if (!StringUtil.isEmpty(sessionId)) {
httpRequestBase.addHeader("Cookie", JSESSION_STR + sessionId);
}
return handleHttpRequest(httpRequestBase);
} catch (IOException e) {
Log.e("HttpRemoteManager", "execute http", e);
return new Response(MessageCodes.CONNECT_FAILED, "连接服务器失败");
}
}
protected void configureRequest(final HttpRequestBase request) {
request.addHeader(HttpHeaders.ACCEPT, CONTENT_TYPE_JSON);
request.addHeader(HttpHeaders.USER_AGENT, USER_AGENT);
}
/**
* The handler method that invokes the actual HTTP service when the component is used as a HTTP
* consumer.
*
* @param exchange the Exchange
* @throws HandlerException handler exception
*/
@Override
public void handleMessage(final Exchange exchange) throws HandlerException {
HttpClient httpclient = new DefaultHttpClient();
try {
HttpMessage httpRequest = _messageComposer.decompose(exchange, new HttpRequestMessage());
HttpRequestBase request = null;
if (_httpMethod.equals(HTTP_GET)) {
request = new HttpGet(_baseAddress);
} else if (_httpMethod.equals(HTTP_POST)) {
request = new HttpPost(_baseAddress);
((HttpPost) request).setEntity(new ByteArrayEntity(httpRequest.getBodyBytes()));
} else if (_httpMethod.equals(HTTP_DELETE)) {
request = new HttpDelete(_baseAddress);
} else if (_httpMethod.equals(HTTP_HEAD)) {
request = new HttpHead(_baseAddress);
} else if (_httpMethod.equals(HTTP_PUT)) {
request = new HttpPut(_baseAddress);
((HttpPut) request).setEntity(new ByteArrayEntity(httpRequest.getBodyBytes()));
} else if (_httpMethod.equals(HTTP_OPTIONS)) {
request = new HttpOptions(_baseAddress);
}
Iterator<Map.Entry<String, List<String>>> entries =
httpRequest.getHeaders().entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, List<String>> entry = entries.next();
String name = entry.getKey();
List<String> values = entry.getValue();
for (String value : values) {
request.addHeader(name, value);
}
}
if (_contentType != null) {
request.addHeader("Content-Type", _contentType);
}
HttpResponse response = httpclient.execute(request);
int status = response.getStatusLine().getStatusCode();
if (status == HttpServletResponse.SC_OK) {
HttpEntity entity = response.getEntity();
HttpResponseMessage httpResponse = new HttpResponseMessage();
Header[] headers = response.getAllHeaders();
for (Header header : headers) {
httpResponse.addHeader(header.getName(), header.getValue());
}
if (entity != null) {
if (entity.getContentType() != null) {
httpResponse.setContentType(new ContentType(entity.getContentType().getValue()));
} else {
httpResponse.setContentType(new ContentType());
}
httpResponse.setBodyFromStream(entity.getContent());
}
httpResponse.setStatus(status);
Message out = _messageComposer.compose(httpResponse, exchange, true);
exchange.send(out);
}
} catch (Exception e) {
throw new HandlerException("Unexpected exception handling HTTP Message", e);
} 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 void remoteQuery(String coreUrl, HttpServletResponse resp) throws IOException {
HttpRequestBase method = null;
HttpEntity httpEntity = null;
try {
String urlstr = coreUrl + queryParams.toQueryString();
boolean isPostOrPutRequest = "POST".equals(req.getMethod()) || "PUT".equals(req.getMethod());
if ("GET".equals(req.getMethod())) {
method = new HttpGet(urlstr);
} else if ("HEAD".equals(req.getMethod())) {
method = new HttpHead(urlstr);
} else if (isPostOrPutRequest) {
HttpEntityEnclosingRequestBase entityRequest =
"POST".equals(req.getMethod()) ? new HttpPost(urlstr) : new HttpPut(urlstr);
InputStream in =
new CloseShieldInputStream(req.getInputStream()); // Prevent close of container streams
HttpEntity entity = new InputStreamEntity(in, req.getContentLength());
entityRequest.setEntity(entity);
method = entityRequest;
} else if ("DELETE".equals(req.getMethod())) {
method = new HttpDelete(urlstr);
} else {
throw new SolrException(
SolrException.ErrorCode.SERVER_ERROR, "Unexpected method type: " + req.getMethod());
}
for (Enumeration<String> e = req.getHeaderNames(); e.hasMoreElements(); ) {
String headerName = e.nextElement();
if (!"host".equalsIgnoreCase(headerName)
&& !"authorization".equalsIgnoreCase(headerName)
&& !"accept".equalsIgnoreCase(headerName)) {
method.addHeader(headerName, req.getHeader(headerName));
}
}
// These headers not supported for HttpEntityEnclosingRequests
if (method instanceof HttpEntityEnclosingRequest) {
method.removeHeaders(TRANSFER_ENCODING_HEADER);
method.removeHeaders(CONTENT_LENGTH_HEADER);
}
final HttpResponse response =
solrDispatchFilter.httpClient.execute(
method, HttpClientUtil.createNewHttpClientRequestContext());
int httpStatus = response.getStatusLine().getStatusCode();
httpEntity = response.getEntity();
resp.setStatus(httpStatus);
for (HeaderIterator responseHeaders = response.headerIterator();
responseHeaders.hasNext(); ) {
Header header = responseHeaders.nextHeader();
// We pull out these two headers below because they can cause chunked
// encoding issues with Tomcat
if (header != null
&& !header.getName().equalsIgnoreCase(TRANSFER_ENCODING_HEADER)
&& !header.getName().equalsIgnoreCase(CONNECTION_HEADER)) {
resp.addHeader(header.getName(), header.getValue());
}
}
if (httpEntity != null) {
if (httpEntity.getContentEncoding() != null)
resp.setCharacterEncoding(httpEntity.getContentEncoding().getValue());
if (httpEntity.getContentType() != null)
resp.setContentType(httpEntity.getContentType().getValue());
InputStream is = httpEntity.getContent();
OutputStream os = resp.getOutputStream();
IOUtils.copyLarge(is, os);
}
} catch (IOException e) {
sendError(
new SolrException(
SolrException.ErrorCode.SERVER_ERROR,
"Error trying to proxy request for url: " + coreUrl,
e));
} finally {
Utils.consumeFully(httpEntity);
}
}
S3Response invoke(
@Nullable String bucket, @Nullable String object, @Nullable String temporaryEndpoint)
throws S3Exception, CloudException, InternalException {
if (wire.isDebugEnabled()) {
wire.debug("");
wire.debug(
"----------------------------------------------------------------------------------");
}
try {
StringBuilder url = new StringBuilder();
boolean leaveOpen = false;
HttpRequestBase method;
HttpClient client;
int status;
if (provider.getEC2Provider().isAWS()) {
url.append("https://");
if (temporaryEndpoint == null) {
boolean validDomainName = isValidDomainName(bucket);
if (bucket != null && validDomainName) {
url.append(bucket);
url.append(".");
}
url.append("s3.amazonaws.com/");
if (bucket != null && !validDomainName) {
url.append(bucket);
url.append("/");
}
} else {
url.append(temporaryEndpoint);
url.append("/");
}
} else if (provider.getEC2Provider().isStorage()
&& "google".equalsIgnoreCase(provider.getProviderName())) {
url.append("https://");
if (temporaryEndpoint == null) {
if (bucket != null) {
url.append(bucket);
url.append(".");
}
url.append("commondatastorage.googleapis.com/");
} else {
url.append(temporaryEndpoint);
url.append("/");
}
} else {
int idx = 0;
if (!provider.getContext().getEndpoint().startsWith("http")) {
url.append("https://");
} else {
idx = provider.getContext().getEndpoint().indexOf("https://");
if (idx == -1) {
idx = "http://".length();
url.append("http://");
} else {
idx = "https://".length();
url.append("https://");
}
}
String service = "";
if (provider.getEC2Provider().isEucalyptus()) {
service = "Walrus/";
}
if (temporaryEndpoint == null) {
url.append(provider.getContext().getEndpoint().substring(idx));
if (!provider.getContext().getEndpoint().endsWith("/")) {
url.append("/").append(service);
} else {
url.append(service);
}
} else {
url.append(temporaryEndpoint);
url.append("/");
url.append(service);
}
if (bucket != null) {
url.append(bucket);
url.append("/");
}
}
if (object != null) {
url.append(object);
} else if (parameters != null) {
boolean first = true;
if (object != null && object.indexOf('?') != -1) {
first = false;
}
for (Map.Entry<String, String> entry : parameters.entrySet()) {
String key = entry.getKey();
String val = entry.getValue();
if (first) {
url.append("?");
first = false;
} else {
url.append("&");
}
if (val != null) {
url.append(AWSCloud.encode(key, false));
url.append("=");
url.append(AWSCloud.encode(val, false));
} else {
url.append(AWSCloud.encode(key, false));
}
}
}
if (provider.getEC2Provider().isStorage()
&& provider.getProviderName().equalsIgnoreCase("Google")) {
headers.put(AWSCloud.P_GOOG_DATE, getDate());
} else {
headers.put(AWSCloud.P_AWS_DATE, getDate());
}
method = action.getMethod(url.toString());
if (headers != null) {
for (Map.Entry<String, String> entry : headers.entrySet()) {
method.addHeader(entry.getKey(), entry.getValue());
}
}
if (contentType == null && body != null) {
contentType = "application/xml";
method.addHeader("Content-Type", contentType);
}
try {
String hash = null;
String signature;
signature =
provider.signS3(
new String(provider.getContext().getAccessPublic(), "utf-8"),
provider.getContext().getAccessPrivate(),
method.getMethod(),
hash,
contentType,
headers,
bucket,
object);
method.addHeader(AWSCloud.P_CFAUTH, signature);
} catch (UnsupportedEncodingException e) {
logger.error(e);
e.printStackTrace();
throw new InternalException(e);
}
if (body != null) {
try {
((HttpEntityEnclosingRequestBase) method)
.setEntity(new StringEntity(body, "application/xml", "utf-8"));
} catch (UnsupportedEncodingException e) {
throw new InternalException(e);
}
} else if (uploadFile != null) {
((HttpEntityEnclosingRequestBase) method)
.setEntity(new FileEntity(uploadFile, contentType));
}
attempts++;
client = getClient(url.toString(), body == null && uploadFile == null);
if (wire.isDebugEnabled()) {
wire.debug("[" + url.toString() + "]");
wire.debug(method.getRequestLine().toString());
for (Header header : method.getAllHeaders()) {
wire.debug(header.getName() + ": " + header.getValue());
}
wire.debug("");
if (body != null) {
try {
wire.debug(EntityUtils.toString(((HttpEntityEnclosingRequestBase) method).getEntity()));
} catch (IOException ignore) {
}
wire.debug("");
} else if (uploadFile != null) {
wire.debug("-- file upload --");
wire.debug("");
}
}
S3Response response = new S3Response();
HttpResponse httpResponse;
try {
httpResponse = client.execute(method);
if (wire.isDebugEnabled()) {
wire.debug(httpResponse.getStatusLine().toString());
for (Header header : httpResponse.getAllHeaders()) {
wire.debug(header.getName() + ": " + header.getValue());
}
wire.debug("");
}
status = httpResponse.getStatusLine().getStatusCode();
} catch (IOException e) {
logger.error(url + ": " + e.getMessage());
e.printStackTrace();
throw new InternalException(e);
}
response.headers = httpResponse.getAllHeaders();
HttpEntity entity = httpResponse.getEntity();
InputStream input = null;
if (entity != null) {
try {
input = entity.getContent();
} catch (IOException e) {
throw new CloudException(e);
}
}
try {
if (status == HttpServletResponse.SC_OK
|| status == HttpServletResponse.SC_CREATED
|| status == HttpServletResponse.SC_ACCEPTED) {
Header clen = httpResponse.getFirstHeader("Content-Length");
long len = -1L;
if (clen != null) {
len = Long.parseLong(clen.getValue());
}
if (len != 0L) {
try {
Header ct = httpResponse.getFirstHeader("Content-Type");
if (ct != null
&& (ct.getValue().startsWith("application/xml")
|| ct.getValue().startsWith("text/xml"))) {
try {
response.document = parseResponse(input);
return response;
} finally {
input.close();
}
} else if (ct != null
&& ct.getValue().startsWith("application/octet-stream")
&& len < 1) {
return null;
} else {
response.contentLength = len;
if (ct != null) {
response.contentType = ct.getValue();
}
response.input = input;
response.method = method;
leaveOpen = true;
return response;
}
} catch (IOException e) {
logger.error(e);
e.printStackTrace();
throw new CloudException(e);
}
} else {
return response;
}
} else if (status == HttpServletResponse.SC_NO_CONTENT) {
return response;
} else if (status == HttpServletResponse.SC_NOT_FOUND) {
throw new S3Exception(status, null, null, "Object not found.");
} else {
if (status == HttpServletResponse.SC_SERVICE_UNAVAILABLE
|| status == HttpServletResponse.SC_INTERNAL_SERVER_ERROR) {
if (attempts >= 5) {
String msg;
if (status == HttpServletResponse.SC_SERVICE_UNAVAILABLE) {
msg = "Cloud service is currently unavailable.";
} else {
msg = "The cloud service encountered a server error while processing your request.";
}
logger.error(msg);
throw new CloudException(msg);
} else {
leaveOpen = true;
if (input != null) {
try {
input.close();
} catch (IOException ignore) {
}
}
try {
Thread.sleep(5000L);
} catch (InterruptedException ignore) {
}
return invoke(bucket, object);
}
}
try {
Document doc;
try {
logger.warn("Received error code: " + status);
doc = parseResponse(input);
} finally {
input.close();
}
if (doc != null) {
String endpoint = null, code = null, message = null, requestId = null;
NodeList blocks = doc.getElementsByTagName("Error");
if (blocks.getLength() > 0) {
Node error = blocks.item(0);
NodeList attrs;
attrs = error.getChildNodes();
for (int i = 0; i < attrs.getLength(); i++) {
Node attr = attrs.item(i);
if (attr.getNodeName().equals("Code") && attr.hasChildNodes()) {
code = attr.getFirstChild().getNodeValue().trim();
} else if (attr.getNodeName().equals("Message") && attr.hasChildNodes()) {
message = attr.getFirstChild().getNodeValue().trim();
} else if (attr.getNodeName().equals("RequestId") && attr.hasChildNodes()) {
requestId = attr.getFirstChild().getNodeValue().trim();
} else if (attr.getNodeName().equals("Endpoint") && attr.hasChildNodes()) {
endpoint = attr.getFirstChild().getNodeValue().trim();
}
}
}
if (endpoint != null && code.equals("TemporaryRedirect")) {
if (temporaryEndpoint != null) {
throw new CloudException("Too deep redirect to " + endpoint);
} else {
return invoke(bucket, object, endpoint);
}
} else {
if (message == null) {
throw new CloudException(
"Unable to identify error condition: "
+ status
+ "/"
+ requestId
+ "/"
+ code);
}
throw new S3Exception(status, requestId, code, message);
}
} else {
throw new CloudException("Unable to parse error.");
}
} catch (IOException e) {
if (status == HttpServletResponse.SC_FORBIDDEN) {
throw new S3Exception(
status, "", "AccessForbidden", "Access was denied without explanation.");
}
throw new CloudException(e);
} catch (RuntimeException e) {
throw new CloudException(e);
} catch (Error e) {
throw new CloudException(e);
}
}
} finally {
if (!leaveOpen) {
if (input != null) {
try {
input.close();
} catch (IOException ignore) {
}
}
}
}
} finally {
if (wire.isDebugEnabled()) {
wire.debug(
"----------------------------------------------------------------------------------");
wire.debug("");
}
}
}
public void addRequestHeader(String key, String value) {
method.addHeader(key, value);
}
/**
* Generate and make the necessary HTTP request.
*
* @return
* @throws IOException
* @throws ClientProtocolException
* @throws URISyntaxException
* @throws Exception
*/
public HttpResponse generateRequest()
throws ClientProtocolException, IOException, URISyntaxException {
String URL = this.getRequestURL();
// List<NameValuePair> queryParamsNVPair = null;
HttpRequestBase request = null;
switch (method) {
case "GET":
request = new HttpGet(URL);
for (String headerKey : this.headers.keySet()) {
request.addHeader(headerKey, headers.get(headerKey));
}
break;
case "POST":
HttpPost postRequest = new HttpPost(URL);
for (String headerKey : this.headers.keySet()) {
postRequest.addHeader(headerKey, headers.get(headerKey));
}
if (bodyParams != null) {
StringEntity requestBodySE = new StringEntity(bodyParams.toString());
requestBodySE.setContentType("application/json");
postRequest.setEntity(requestBodySE);
}
request = postRequest;
break;
case "PUT":
HttpPut putRequest = new HttpPut(URL);
for (String headerKey : this.headers.keySet()) {
putRequest.addHeader(headerKey, headers.get(headerKey));
}
if (bodyParams != null) {
StringEntity requestBodySE = new StringEntity(bodyParams.toString());
System.out.println(requestBodySE.toString());
requestBodySE.setContentEncoding("application/json");
putRequest.setEntity(requestBodySE);
}
request = putRequest;
System.out.println(request.getURI().toString());
break;
case "DELETE":
request = new HttpDelete(URL);
for (String headerKey : this.headers.keySet()) {
request.addHeader(headerKey, headers.get(headerKey));
}
break;
default:
break;
}
if (queryParams != null) {
URIBuilder getUriBuilder = new URIBuilder(request.getURI());
Iterator<?> paramKeys = queryParams.keys();
while (paramKeys.hasNext()) {
String param = (String) paramKeys.next();
try {
getUriBuilder.addParameter(param, queryParams.getString(param));
} catch (JSONException e) {
e.printStackTrace();
}
}
URI getUri = getUriBuilder.build();
((HttpRequestBase) request).setURI(getUri);
}
HttpResponse response = sbgClient.execute(request);
return response;
}
/* (non-Javadoc)
* @see java.net.URLConnection#getInputStream()
*/
@Override
public InputStream getInputStream() throws IOException {
try {
if (m_client == null) {
connect();
}
// Build URL
int port = m_url.getPort() > 0 ? m_url.getPort() : m_url.getDefaultPort();
URIBuilder ub = new URIBuilder();
ub.setPort(port);
ub.setScheme(m_url.getProtocol());
ub.setHost(m_url.getHost());
ub.setPath(m_url.getPath());
ub.setQuery(m_url.getQuery());
// Build Request
HttpRequestBase request = null;
if (m_request != null && m_request.getMethod().equalsIgnoreCase("post")) {
final Content cnt = m_request.getContent();
HttpPost post = new HttpPost(ub.build());
ContentType contentType = ContentType.create(cnt.getType());
LOG.info("Processing POST request for %s", contentType);
if (contentType
.getMimeType()
.equals(ContentType.APPLICATION_FORM_URLENCODED.getMimeType())) {
FormFields fields = JaxbUtils.unmarshal(FormFields.class, cnt.getData());
post.setEntity(fields.getEntity());
} else {
StringEntity entity = new StringEntity(cnt.getData(), contentType);
post.setEntity(entity);
}
request = post;
} else {
request = new HttpGet(ub.build());
}
if (m_request != null) {
// Add Custom Headers
for (Header header : m_request.getHeaders()) {
request.addHeader(header.getName(), header.getValue());
}
}
// Add User Authentication
String[] userInfo = m_url.getUserInfo() == null ? null : m_url.getUserInfo().split(":");
if (userInfo != null) {
UsernamePasswordCredentials credentials =
new UsernamePasswordCredentials(userInfo[0], userInfo[1]);
request.addHeader(BasicScheme.authenticate(credentials, "UTF-8", false));
}
// Get Response
HttpResponse response = m_client.execute(request);
return response.getEntity().getContent();
} catch (Exception e) {
throw new IOException(
"Can't retrieve "
+ m_url.getPath()
+ " from "
+ m_url.getHost()
+ " because "
+ e.getMessage(),
e);
}
}
@SuppressWarnings("deprecation")
@Override
public void filterHttpRequest(SubmitContext context, HttpRequestInterface<?> request) {
HttpRequestBase httpMethod =
(HttpRequestBase) context.getProperty(BaseHttpRequestTransport.HTTP_METHOD);
String path = PropertyExpander.expandProperties(context, request.getPath());
StringBuffer query = new StringBuffer();
String encoding =
System.getProperty("soapui.request.encoding", StringUtils.unquote(request.getEncoding()));
StringToStringMap responseProperties =
(StringToStringMap) context.getProperty(BaseHttpRequestTransport.RESPONSE_PROPERTIES);
MimeMultipart formMp =
"multipart/form-data".equals(request.getMediaType())
&& httpMethod instanceof HttpEntityEnclosingRequestBase
? new MimeMultipart()
: null;
RestParamsPropertyHolder params = request.getParams();
for (int c = 0; c < params.getPropertyCount(); c++) {
RestParamProperty param = params.getPropertyAt(c);
String value = PropertyExpander.expandProperties(context, param.getValue());
responseProperties.put(param.getName(), value);
List<String> valueParts =
sendEmptyParameters(request) || (!StringUtils.hasContent(value) && param.getRequired())
? RestUtils.splitMultipleParametersEmptyIncluded(
value, request.getMultiValueDelimiter())
: RestUtils.splitMultipleParameters(value, request.getMultiValueDelimiter());
// skip HEADER and TEMPLATE parameter encoding (TEMPLATE is encoded by
// the URI handling further down)
if (value != null
&& param.getStyle() != ParameterStyle.HEADER
&& param.getStyle() != ParameterStyle.TEMPLATE
&& !param.isDisableUrlEncoding()) {
try {
if (StringUtils.hasContent(encoding)) {
value = URLEncoder.encode(value, encoding);
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, URLEncoder.encode(valueParts.get(i), encoding));
} else {
value = URLEncoder.encode(value);
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, URLEncoder.encode(valueParts.get(i)));
}
} catch (UnsupportedEncodingException e1) {
SoapUI.logError(e1);
value = URLEncoder.encode(value);
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, URLEncoder.encode(valueParts.get(i)));
}
// URLEncoder replaces space with "+", but we want "%20".
value = value.replaceAll("\\+", "%20");
for (int i = 0; i < valueParts.size(); i++)
valueParts.set(i, valueParts.get(i).replaceAll("\\+", "%20"));
}
if (param.getStyle() == ParameterStyle.QUERY && !sendEmptyParameters(request)) {
if (!StringUtils.hasContent(value) && !param.getRequired()) continue;
}
switch (param.getStyle()) {
case HEADER:
for (String valuePart : valueParts) httpMethod.addHeader(param.getName(), valuePart);
break;
case QUERY:
if (formMp == null || !request.isPostQueryString()) {
for (String valuePart : valueParts) {
if (query.length() > 0) query.append('&');
query.append(URLEncoder.encode(param.getName()));
query.append('=');
if (StringUtils.hasContent(valuePart)) query.append(valuePart);
}
} else {
try {
addFormMultipart(
request, formMp, param.getName(), responseProperties.get(param.getName()));
} catch (MessagingException e) {
SoapUI.logError(e);
}
}
break;
case TEMPLATE:
try {
value =
getEncodedValue(
value,
encoding,
param.isDisableUrlEncoding(),
request.getSettings().getBoolean(HttpSettings.ENCODED_URLS));
path = path.replaceAll("\\{" + param.getName() + "\\}", value == null ? "" : value);
} catch (UnsupportedEncodingException e) {
SoapUI.logError(e);
}
break;
case MATRIX:
try {
value =
getEncodedValue(
value,
encoding,
param.isDisableUrlEncoding(),
request.getSettings().getBoolean(HttpSettings.ENCODED_URLS));
} catch (UnsupportedEncodingException e) {
SoapUI.logError(e);
}
if (param.getType().equals(XmlBoolean.type.getName())) {
if (value.toUpperCase().equals("TRUE") || value.equals("1")) {
path += ";" + param.getName();
}
} else {
path += ";" + param.getName();
if (StringUtils.hasContent(value)) {
path += "=" + value;
}
}
break;
case PLAIN:
break;
}
}
if (request.getSettings().getBoolean(HttpSettings.FORWARD_SLASHES))
path = PathUtils.fixForwardSlashesInPath(path);
if (PathUtils.isHttpPath(path)) {
try {
// URI(String) automatically URLencodes the input, so we need to
// decode it first...
URI uri = new URI(path, request.getSettings().getBoolean(HttpSettings.ENCODED_URLS));
context.setProperty(BaseHttpRequestTransport.REQUEST_URI, uri);
java.net.URI oldUri = httpMethod.getURI();
httpMethod.setURI(
HttpUtils.createUri(
oldUri.getScheme(),
oldUri.getRawUserInfo(),
oldUri.getHost(),
oldUri.getPort(),
oldUri.getRawPath(),
uri.getEscapedQuery(),
oldUri.getRawFragment()));
} catch (Exception e) {
SoapUI.logError(e);
}
} else if (StringUtils.hasContent(path)) {
try {
java.net.URI oldUri = httpMethod.getURI();
String pathToSet =
StringUtils.hasContent(oldUri.getRawPath()) && !"/".equals(oldUri.getRawPath())
? oldUri.getRawPath() + path
: path;
java.net.URI newUri =
URIUtils.createURI(
oldUri.getScheme(),
oldUri.getHost(),
oldUri.getPort(),
pathToSet,
oldUri.getQuery(),
oldUri.getFragment());
httpMethod.setURI(newUri);
context.setProperty(
BaseHttpRequestTransport.REQUEST_URI,
new URI(
newUri.toString(), request.getSettings().getBoolean(HttpSettings.ENCODED_URLS)));
} catch (Exception e) {
SoapUI.logError(e);
}
}
if (query.length() > 0 && !request.isPostQueryString()) {
try {
java.net.URI oldUri = httpMethod.getURI();
httpMethod.setURI(
URIUtils.createURI(
oldUri.getScheme(),
oldUri.getHost(),
oldUri.getPort(),
oldUri.getRawPath(),
query.toString(),
oldUri.getFragment()));
} catch (Exception e) {
SoapUI.logError(e);
}
}
if (request instanceof RestRequest) {
String acceptEncoding = ((RestRequest) request).getAccept();
if (StringUtils.hasContent(acceptEncoding)) {
httpMethod.setHeader("Accept", acceptEncoding);
}
}
if (formMp != null) {
// create request message
try {
if (request.hasRequestBody() && httpMethod instanceof HttpEntityEnclosingRequest) {
String requestContent =
PropertyExpander.expandProperties(
context, request.getRequestContent(), request.isEntitizeProperties());
if (StringUtils.hasContent(requestContent)) {
initRootPart(request, requestContent, formMp);
}
}
for (Attachment attachment : request.getAttachments()) {
MimeBodyPart part = new PreencodedMimeBodyPart("binary");
if (attachment instanceof FileAttachment<?>) {
String name = attachment.getName();
if (StringUtils.hasContent(attachment.getContentID())
&& !name.equals(attachment.getContentID())) name = attachment.getContentID();
part.setDisposition(
"form-data; name=\"" + name + "\"; filename=\"" + attachment.getName() + "\"");
} else part.setDisposition("form-data; name=\"" + attachment.getName() + "\"");
part.setDataHandler(new DataHandler(new AttachmentDataSource(attachment)));
formMp.addBodyPart(part);
}
MimeMessage message = new MimeMessage(AttachmentUtils.JAVAMAIL_SESSION);
message.setContent(formMp);
message.saveChanges();
RestRequestMimeMessageRequestEntity mimeMessageRequestEntity =
new RestRequestMimeMessageRequestEntity(message, request);
((HttpEntityEnclosingRequest) httpMethod).setEntity(mimeMessageRequestEntity);
httpMethod.setHeader("Content-Type", mimeMessageRequestEntity.getContentType().getValue());
httpMethod.setHeader("MIME-Version", "1.0");
} catch (Throwable e) {
SoapUI.logError(e);
}
} else if (request.hasRequestBody() && httpMethod instanceof HttpEntityEnclosingRequest) {
if (StringUtils.hasContent(request.getMediaType()))
httpMethod.setHeader(
"Content-Type", getContentTypeHeader(request.getMediaType(), encoding));
if (request.isPostQueryString()) {
try {
((HttpEntityEnclosingRequest) httpMethod).setEntity(new StringEntity(query.toString()));
} catch (UnsupportedEncodingException e) {
SoapUI.logError(e);
}
} else {
String requestContent =
PropertyExpander.expandProperties(
context, request.getRequestContent(), request.isEntitizeProperties());
List<Attachment> attachments = new ArrayList<Attachment>();
for (Attachment attachment : request.getAttachments()) {
if (attachment.getContentType().equals(request.getMediaType())) {
attachments.add(attachment);
}
}
if (StringUtils.hasContent(requestContent) && attachments.isEmpty()) {
try {
byte[] content =
encoding == null ? requestContent.getBytes() : requestContent.getBytes(encoding);
((HttpEntityEnclosingRequest) httpMethod).setEntity(new ByteArrayEntity(content));
} catch (UnsupportedEncodingException e) {
((HttpEntityEnclosingRequest) httpMethod)
.setEntity(new ByteArrayEntity(requestContent.getBytes()));
}
} else if (attachments.size() > 0) {
try {
MimeMultipart mp = null;
if (StringUtils.hasContent(requestContent)) {
mp = new MimeMultipart();
initRootPart(request, requestContent, mp);
} else if (attachments.size() == 1) {
((HttpEntityEnclosingRequest) httpMethod)
.setEntity(new InputStreamEntity(attachments.get(0).getInputStream(), -1));
httpMethod.setHeader(
"Content-Type", getContentTypeHeader(request.getMediaType(), encoding));
}
if (((HttpEntityEnclosingRequest) httpMethod).getEntity() == null) {
if (mp == null) mp = new MimeMultipart();
// init mimeparts
AttachmentUtils.addMimeParts(request, attachments, mp, new StringToStringMap());
// create request message
MimeMessage message = new MimeMessage(AttachmentUtils.JAVAMAIL_SESSION);
message.setContent(mp);
message.saveChanges();
RestRequestMimeMessageRequestEntity mimeMessageRequestEntity =
new RestRequestMimeMessageRequestEntity(message, request);
((HttpEntityEnclosingRequest) httpMethod).setEntity(mimeMessageRequestEntity);
httpMethod.setHeader(
"Content-Type",
getContentTypeHeader(
mimeMessageRequestEntity.getContentType().getValue(), encoding));
httpMethod.setHeader("MIME-Version", "1.0");
}
} catch (Exception e) {
SoapUI.logError(e);
}
}
}
}
}
public NamedList<Object> request(final SolrRequest request, final ResponseParser processor)
throws SolrServerException, IOException {
HttpRequestBase 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 = DEFAULT_PATH;
}
ResponseParser parser = request.getResponseParser();
if (parser == null) {
parser = this.parser;
}
// The parser 'wt=' and 'version=' params are used instead of the original
// params
ModifiableSolrParams wparams = new ModifiableSolrParams(params);
if (parser != null) {
wparams.set(CommonParams.WT, parser.getWriterType());
wparams.set(CommonParams.VERSION, parser.getVersion());
}
if (invariantParams != null) {
wparams.add(invariantParams);
}
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 HttpGet(baseUrl + path + ClientUtils.toQueryString(wparams, false));
} else if (SolrRequest.METHOD.POST == request.getMethod()) {
String url = baseUrl + path;
boolean hasNullStreamName = false;
if (streams != null) {
for (ContentStream cs : streams) {
if (cs.getName() == null) {
hasNullStreamName = true;
break;
}
}
}
boolean isMultipart =
(this.useMultiPartPost || (streams != null && streams.size() > 1))
&& !hasNullStreamName;
// only send this list of params as query string params
ModifiableSolrParams queryParams = new ModifiableSolrParams();
for (String param : this.queryParams) {
String[] value = wparams.getParams(param);
if (value != null) {
for (String v : value) {
queryParams.add(param, v);
}
wparams.remove(param);
}
}
LinkedList<NameValuePair> postParams = new LinkedList<NameValuePair>();
if (streams == null || isMultipart) {
HttpPost post = new HttpPost(url + ClientUtils.toQueryString(queryParams, false));
post.setHeader("Content-Charset", "UTF-8");
if (!isMultipart) {
post.addHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
}
List<FormBodyPart> parts = new LinkedList<FormBodyPart>();
Iterator<String> iter = wparams.getParameterNamesIterator();
while (iter.hasNext()) {
String p = iter.next();
String[] vals = wparams.getParams(p);
if (vals != null) {
for (String v : vals) {
if (isMultipart) {
parts.add(new FormBodyPart(p, new StringBody(v, Charset.forName("UTF-8"))));
} else {
postParams.add(new BasicNameValuePair(p, v));
}
}
}
}
if (isMultipart && streams != null) {
for (ContentStream content : streams) {
String contentType = content.getContentType();
if (contentType == null) {
contentType = BinaryResponseParser.BINARY_CONTENT_TYPE; // default
}
String name = content.getName();
if (name == null) {
name = "";
}
parts.add(
new FormBodyPart(
name,
new InputStreamBody(
content.getStream(), contentType, content.getName())));
}
}
if (parts.size() > 0) {
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.STRICT);
for (FormBodyPart p : parts) {
entity.addPart(p);
}
post.setEntity(entity);
} else {
// not using multipart
post.setEntity(new UrlEncodedFormEntity(postParams, "UTF-8"));
}
method = post;
}
// It is has one stream, it is the post body, put the params in the URL
else {
String pstr = ClientUtils.toQueryString(wparams, false);
HttpPost post = new HttpPost(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.setEntity(
new InputStreamEntity(contentStream[0].getStream(), -1) {
@Override
public Header getContentType() {
return new BasicHeader("Content-Type", contentStream[0].getContentType());
}
@Override
public boolean isRepeatable() {
return false;
}
});
} else {
post.setEntity(
new InputStreamEntity(contentStream[0].getStream(), -1) {
@Override
public Header getContentType() {
return new BasicHeader("Content-Type", contentStream[0].getContentType());
}
@Override
public boolean isRepeatable() {
return false;
}
});
}
method = post;
}
} else {
throw new SolrServerException("Unsupported method: " + request.getMethod());
}
} catch (NoHttpResponseException r) {
method = null;
if (is != null) {
is.close();
}
// If out of tries then just rethrow (as normal error).
if (tries < 1) {
throw r;
}
}
}
} catch (IOException ex) {
throw new SolrServerException("error reading streams", ex);
}
// XXX client already has this set, is this needed?
method.getParams().setParameter(ClientPNames.HANDLE_REDIRECTS, followRedirects);
method.addHeader("User-Agent", AGENT);
InputStream respBody = null;
boolean shouldClose = true;
boolean success = false;
try {
// Execute the method.
final HttpResponse response = httpClient.execute(method);
int httpStatus = response.getStatusLine().getStatusCode();
// Read the contents
respBody = response.getEntity().getContent();
Header ctHeader = response.getLastHeader("content-type");
String contentType;
if (ctHeader != null) {
contentType = ctHeader.getValue();
} else {
contentType = "";
}
// handle some http level checks before trying to parse the response
switch (httpStatus) {
case HttpStatus.SC_OK:
case HttpStatus.SC_BAD_REQUEST:
case HttpStatus.SC_CONFLICT: // 409
break;
case HttpStatus.SC_MOVED_PERMANENTLY:
case HttpStatus.SC_MOVED_TEMPORARILY:
if (!followRedirects) {
throw new SolrServerException(
"Server at " + getBaseURL() + " sent back a redirect (" + httpStatus + ").");
}
break;
default:
if (processor == null) {
throw new RemoteSolrException(
httpStatus,
"Server at "
+ getBaseURL()
+ " returned non ok status:"
+ httpStatus
+ ", message:"
+ response.getStatusLine().getReasonPhrase(),
null);
}
}
if (processor == null) {
// no processor specified, return raw stream
NamedList<Object> rsp = new NamedList<Object>();
rsp.add("stream", respBody);
// Only case where stream should not be closed
shouldClose = false;
success = true;
return rsp;
}
String procCt = processor.getContentType();
if (procCt != null) {
if (!contentType.equals(procCt)) {
// unexpected content type
String msg = "Expected content type " + procCt + " but got " + contentType + ".";
Header encodingHeader = response.getEntity().getContentEncoding();
String encoding;
if (encodingHeader != null) {
encoding = encodingHeader.getValue();
} else {
encoding = "UTF-8"; // try UTF-8
}
try {
msg = msg + " " + IOUtils.toString(respBody, encoding);
} catch (IOException e) {
throw new RemoteSolrException(
httpStatus, "Could not parse response with encoding " + encoding, e);
}
RemoteSolrException e = new RemoteSolrException(httpStatus, msg, null);
throw e;
}
}
// if(true) {
// ByteArrayOutputStream copy = new ByteArrayOutputStream();
// IOUtils.copy(respBody, copy);
// String val = new String(copy.toByteArray());
// System.out.println(">RESPONSE>"+val+"<"+val.length());
// respBody = new ByteArrayInputStream(copy.toByteArray());
// }
NamedList<Object> rsp = null;
String charset = EntityUtils.getContentCharSet(response.getEntity());
try {
rsp = processor.processResponse(respBody, charset);
} catch (Exception e) {
throw new RemoteSolrException(httpStatus, e.getMessage(), e);
}
if (httpStatus != HttpStatus.SC_OK) {
String reason = null;
try {
NamedList err = (NamedList) rsp.get("error");
if (err != null) {
reason = (String) err.get("msg");
// TODO? get the trace?
}
} catch (Exception ex) {
}
if (reason == null) {
StringBuilder msg = new StringBuilder();
msg.append(response.getStatusLine().getReasonPhrase());
msg.append("\n\n");
msg.append("request: " + method.getURI());
reason = java.net.URLDecoder.decode(msg.toString(), UTF_8);
}
throw new RemoteSolrException(httpStatus, reason, null);
}
success = true;
return rsp;
} catch (ConnectException e) {
throw new SolrServerException("Server refused connection at: " + getBaseURL(), e);
} catch (SocketTimeoutException e) {
throw new SolrServerException(
"Timeout occured while waiting response from server at: " + getBaseURL(), e);
} catch (IOException e) {
throw new SolrServerException(
"IOException occured when talking to server at: " + getBaseURL(), e);
} finally {
if (respBody != null && shouldClose) {
try {
respBody.close();
} catch (Throwable t) {
} // ignore
if (!success) {
method.abort();
}
}
}
}
/**
* @param req
* @param headers
*/
private void addHeaders(HttpRequestBase req, Map<String, String> headers) {
if (headers == null) return;
for (Map.Entry<String, String> h : headers.entrySet()) {
req.addHeader(h.getKey(), h.getValue());
}
}
/**
* @param uri Url.
* @param params Params.
* @param demo Use demo node.
* @param mtd Method.
* @param headers Headers.
* @param body Body.
*/
protected RestResult executeRest(
String uri,
Map<String, Object> params,
boolean demo,
String mtd,
Map<String, Object> headers,
String body)
throws IOException, URISyntaxException {
if (log.isDebugEnabled())
log.debug(
"Start execute REST command [method="
+ mtd
+ ", uri=/"
+ (uri == null ? "" : uri)
+ ", parameters="
+ params
+ "]");
final URIBuilder builder;
if (demo) {
// try start demo if needed.
AgentClusterDemo.testDrive(cfg);
// null if demo node not started yet.
if (cfg.demoNodeUri() == null) return RestResult.fail("Demo node is not started yet.", 404);
builder = new URIBuilder(cfg.demoNodeUri());
} else builder = new URIBuilder(cfg.nodeUri());
if (builder.getPort() == -1) builder.setPort(DFLT_NODE_PORT);
if (uri != null) {
if (!uri.startsWith("/") && !cfg.nodeUri().endsWith("/")) uri = '/' + uri;
builder.setPath(uri);
}
if (params != null) {
for (Map.Entry<String, Object> entry : params.entrySet()) {
if (entry.getValue() != null)
builder.addParameter(entry.getKey(), entry.getValue().toString());
}
}
HttpRequestBase httpReq = null;
try {
if ("GET".equalsIgnoreCase(mtd)) httpReq = new HttpGet(builder.build());
else if ("POST".equalsIgnoreCase(mtd)) {
HttpPost post;
if (body == null) {
List<NameValuePair> nvps = builder.getQueryParams();
builder.clearParameters();
post = new HttpPost(builder.build());
if (!nvps.isEmpty()) post.setEntity(new UrlEncodedFormEntity(nvps));
} else {
post = new HttpPost(builder.build());
post.setEntity(new StringEntity(body));
}
httpReq = post;
} else throw new IOException("Unknown HTTP-method: " + mtd);
if (headers != null) {
for (Map.Entry<String, Object> entry : headers.entrySet())
httpReq.addHeader(
entry.getKey(), entry.getValue() == null ? null : entry.getValue().toString());
}
try (CloseableHttpResponse resp = httpClient.execute(httpReq)) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
resp.getEntity().writeTo(out);
Charset charset = Charsets.UTF_8;
Header encodingHdr = resp.getEntity().getContentEncoding();
if (encodingHdr != null) {
String encoding = encodingHdr.getValue();
charset = Charsets.toCharset(encoding);
}
return RestResult.success(
resp.getStatusLine().getStatusCode(), new String(out.toByteArray(), charset));
} catch (ConnectException e) {
log.info("Failed connect to node and execute REST command [uri=" + builder.build() + "]");
return RestResult.fail("Failed connect to node and execute REST command.", 404);
}
} finally {
if (httpReq != null) httpReq.reset();
}
}
public void tempRedirectInvoke(
@Nonnull String tempEndpoint,
@Nonnull String method,
@Nonnull String account,
@Nonnull String resource,
@Nonnull String body)
throws CloudException, InternalException {
if (logger.isTraceEnabled()) {
logger.trace(
"enter - " + AzureMethod.class.getName() + ".post(" + account + "," + resource + ")");
}
if (wire.isDebugEnabled()) {
wire.debug(
"POST --------------------------------------------------------> "
+ endpoint
+ account
+ resource);
wire.debug("");
}
try {
HttpClient client = getClient();
String url = tempEndpoint + account + resource;
HttpRequestBase httpMethod = getMethod(method, url);
// If it is networking configuration services
if (httpMethod instanceof HttpPut) {
if (url.endsWith("/services/networking/media")) {
httpMethod.addHeader("Content-Type", "text/plain");
} else {
httpMethod.addHeader("Content-Type", "application/xml;charset=UTF-8");
}
} else {
httpMethod.addHeader("Content-Type", "application/xml;charset=UTF-8");
}
// dmayne version is older for anything to do with images and for disk deletion
if (url.indexOf("/services/images") > -1
|| (httpMethod instanceof HttpDelete && url.indexOf("/services/disks") > -1)) {
httpMethod.addHeader("x-ms-version", "2012-08-01");
} else {
httpMethod.addHeader("x-ms-version", "2012-03-01");
}
if (strategy != null && strategy.getSendAsHeader()) {
httpMethod.addHeader(strategy.getHeaderName(), strategy.getRequestId());
}
if (wire.isDebugEnabled()) {
wire.debug(httpMethod.getRequestLine().toString());
for (Header header : httpMethod.getAllHeaders()) {
wire.debug(header.getName() + ": " + header.getValue());
}
wire.debug("");
if (body != null) {
wire.debug(body);
wire.debug("");
}
}
if (httpMethod instanceof HttpEntityEnclosingRequestBase) {
HttpEntityEnclosingRequestBase entityEnclosingMethod =
(HttpEntityEnclosingRequestBase) httpMethod;
if (body != null) {
try {
entityEnclosingMethod.setEntity(new StringEntity(body, "application/xml", "utf-8"));
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
HttpResponse response;
StatusLine status;
try {
response = client.execute(httpMethod);
status = response.getStatusLine();
} catch (IOException e) {
logger.error(
"post(): Failed to execute HTTP request due to a cloud I/O error: " + e.getMessage());
if (logger.isTraceEnabled()) {
e.printStackTrace();
}
throw new CloudException(e);
}
if (logger.isDebugEnabled()) {
logger.debug("post(): HTTP Status " + status);
}
Header[] headers = response.getAllHeaders();
if (wire.isDebugEnabled()) {
wire.debug(status.toString());
for (Header h : headers) {
if (h.getValue() != null) {
wire.debug(h.getName() + ": " + h.getValue().trim());
} else {
wire.debug(h.getName() + ":");
}
}
wire.debug("");
}
if (status.getStatusCode() != HttpServletResponse.SC_OK
&& status.getStatusCode() != HttpServletResponse.SC_CREATED
&& status.getStatusCode() != HttpServletResponse.SC_ACCEPTED) {
logger.error("post(): Expected OK for GET request, got " + status.getStatusCode());
HttpEntity entity = response.getEntity();
if (entity == null) {
throw new AzureException(
CloudErrorType.GENERAL,
status.getStatusCode(),
status.getReasonPhrase(),
"An error was returned without explanation");
}
try {
body = EntityUtils.toString(entity);
} catch (IOException e) {
throw new AzureException(
CloudErrorType.GENERAL,
status.getStatusCode(),
status.getReasonPhrase(),
e.getMessage());
}
if (wire.isDebugEnabled()) {
wire.debug(body);
}
wire.debug("");
AzureException.ExceptionItems items =
AzureException.parseException(status.getStatusCode(), body);
if (items == null) {
throw new CloudException(
CloudErrorType.GENERAL, status.getStatusCode(), "Unknown", "Unknown");
}
logger.error(
"post(): [" + status.getStatusCode() + " : " + items.message + "] " + items.details);
throw new AzureException(items);
}
} finally {
if (logger.isTraceEnabled()) {
logger.trace("exit - " + AzureMethod.class.getName() + ".post()");
}
if (wire.isDebugEnabled()) {
wire.debug("");
wire.debug(
"POST --------------------------------------------------------> "
+ endpoint
+ account
+ resource);
}
}
}