protected HttpResponse sendHttpRequest(
String method, String url, HttpEntity entity, List<NameValuePair> qparams, CallingContext cc)
throws IOException {
HttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(
httpParams, SOCKET_ESTABLISHMENT_TIMEOUT_MILLISECONDS);
HttpConnectionParams.setSoTimeout(httpParams, SERVICE_TIMEOUT_MILLISECONDS);
// setup client
HttpClientFactory factory = (HttpClientFactory) cc.getBean(BeanDefs.HTTP_CLIENT_FACTORY);
HttpClient client = factory.createHttpClient(httpParams);
// support redirecting to handle http: => https: transition
HttpClientParams.setRedirecting(httpParams, true);
// support authenticating
HttpClientParams.setAuthenticating(httpParams, true);
// redirect limit is set to some unreasonably high number
// resets of the socket cause a retry up to MAX_REDIRECTS times,
// so we should be careful not to set this too high...
httpParams.setParameter(ClientPNames.MAX_REDIRECTS, 32);
httpParams.setParameter(ClientPNames.ALLOW_CIRCULAR_REDIRECTS, true);
// context holds authentication state machine, so it cannot be
// shared across independent activities.
HttpContext localContext = new BasicHttpContext();
localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
localContext.setAttribute(ClientContext.CREDS_PROVIDER, credsProvider);
HttpUriRequest request = null;
if (entity == null && (POST.equals(method) || PATCH.equals(method) || PUT.equals(method))) {
throw new IllegalStateException("No body supplied for POST, PATCH or PUT request");
} else if (entity != null
&& !(POST.equals(method) || PATCH.equals(method) || PUT.equals(method))) {
throw new IllegalStateException("Body was supplied for GET or DELETE request");
}
URI nakedUri;
try {
nakedUri = new URI(url);
} catch (Exception e) {
e.printStackTrace();
throw new IllegalStateException(e);
}
if (qparams == null) {
qparams = new ArrayList<NameValuePair>();
}
URI uri;
try {
uri =
new URI(
nakedUri.getScheme(),
nakedUri.getUserInfo(),
nakedUri.getHost(),
nakedUri.getPort(),
nakedUri.getPath(),
URLEncodedUtils.format(qparams, HtmlConsts.UTF8_ENCODE),
null);
} catch (URISyntaxException e1) {
e1.printStackTrace();
throw new IllegalStateException(e1);
}
System.out.println(uri.toString());
if (GET.equals(method)) {
HttpGet get = new HttpGet(uri);
request = get;
} else if (DELETE.equals(method)) {
HttpDelete delete = new HttpDelete(uri);
request = delete;
} else if (PATCH.equals(method)) {
HttpPatch patch = new HttpPatch(uri);
patch.setEntity(entity);
request = patch;
} else if (POST.equals(method)) {
HttpPost post = new HttpPost(uri);
post.setEntity(entity);
request = post;
} else if (PUT.equals(method)) {
HttpPut put = new HttpPut(uri);
put.setEntity(entity);
request = put;
} else {
throw new IllegalStateException("Unexpected request method");
}
HttpResponse resp = client.execute(request);
return resp;
}
@Test
public void unsupportedContentTypeParameter() throws Exception {
HttpPatch patch = new HttpPatch(URI.create(getEndpoint().toString() + "Rooms('1')"));
patch.setHeader(HttpHeaders.CONTENT_TYPE, HttpContentType.APPLICATION_JSON + ";illegal=wrong");
final HttpResponse response = getHttpClient().execute(patch);
assertEquals(
HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE.getStatusCode(),
response.getStatusLine().getStatusCode());
}
static HttpUriRequest createMultiPartRequest(
Request<?> request, Map<String, String> additionalHeaders) throws AuthFailureError {
switch (request.getMethod()) {
case Method.DEPRECATED_GET_OR_POST:
{
// This is the deprecated way that needs to be handled for backwards compatibility.
// If the request's post body is null, then the assumption is that the request is
// GET. Otherwise, it is assumed that the request is a POST.
byte[] postBody = request.getBody();
if (postBody != null) {
HttpPost postRequest = new HttpPost(request.getUrl());
if (request.getBodyContentType() != null)
postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
HttpEntity entity;
entity = new ByteArrayEntity(postBody);
postRequest.setEntity(entity);
return postRequest;
} else {
return new HttpGet(request.getUrl());
}
}
case Method.GET:
return new HttpGet(request.getUrl());
case Method.DELETE:
return new HttpDelete(request.getUrl());
case Method.POST:
{
HttpPost postRequest = new HttpPost(request.getUrl());
if (request.getBodyContentType() != null) {
postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
}
setMultiPartBody(postRequest, request);
return postRequest;
}
case Method.PUT:
{
HttpPut putRequest = new HttpPut(request.getUrl());
if (request.getBodyContentType() != null)
putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
setMultiPartBody(putRequest, request);
return putRequest;
}
// Added in source code of Volley libray.
case Method.PATCH:
{
HttpPatch patchRequest = new HttpPatch(request.getUrl());
if (request.getBodyContentType() != null)
patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
return patchRequest;
}
default:
throw new IllegalStateException("Unknown request method.");
}
}
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();
}
}
/**
* Tests whether a Sparql update is visible within a transaction and if the update is made
* persistent along with the commit.
*
* @throws IOException exception thrown during this function
*/
@Test
public void testIngestNewWithSparqlPatchWithinTransaction() throws IOException {
final String objectInTxCommit = getRandomUniqueId();
/* create new tx */
final String txLocation = createTransaction();
final HttpPost postNew = new HttpPost(txLocation);
postNew.addHeader("Slug", objectInTxCommit);
final String newObjectLocation;
try (CloseableHttpResponse resp = execute(postNew)) {
assertEquals(CREATED.getStatusCode(), getStatus(resp));
newObjectLocation = getLocation(resp);
}
/* update sparql */
final HttpPatch method = new HttpPatch(newObjectLocation);
method.addHeader(CONTENT_TYPE, "application/sparql-update");
final String newTitle = "this is a new title";
method.setEntity(
new StringEntity(
"INSERT { <> <http://purl.org/dc/elements/1.1/title> \"" + newTitle + "\" } WHERE {}"));
assertEquals("Didn't get a NO CONTENT status!", NO_CONTENT.getStatusCode(), getStatus(method));
/* make sure the change was made within the tx */
try (final CloseableDataset dataset = getDataset(new HttpGet(newObjectLocation))) {
assertTrue(
"The sparql update did not succeed within a transaction",
dataset
.asDatasetGraph()
.contains(
ANY, createURI(newObjectLocation), title.asNode(), createLiteral(newTitle)));
}
/* commit */
assertEquals(
NO_CONTENT.getStatusCode(), getStatus(new HttpPost(txLocation + "/fcr:tx/fcr:commit")));
/* it must exist after commit */
try (final CloseableDataset dataset =
getDataset(new HttpGet(serverAddress + objectInTxCommit))) {
assertTrue(
"The inserted triple does not exist after the transaction has committed",
dataset.asDatasetGraph().contains(ANY, ANY, title.asNode(), createLiteral(newTitle)));
}
}
public boolean patchObject(String path, JSONObject body) {
log.info("patchRequest(" + path + ")");
// http://msdn.microsoft.com/en-us/library/windowsazure/dn151671.aspx
HttpPatch httpPatch = new HttpPatch(getAPIEndPoint(path));
httpPatch.addHeader("Authorization", this.getToken());
// patch.addHeader("Content-Type", "application/json;odata=verbose");
httpPatch.addHeader("Content-Type", "application/json;charset=utf-8;odata=verbose");
httpPatch.addHeader("DataServiceVersion", "3.0;NetFx");
httpPatch.addHeader("MaxDataServiceVersion", "3.0;NetFx");
httpPatch.addHeader("Accept", "application/atom+xml");
StringEntity postEntity = null;
try {
postEntity = new StringEntity(body.toString(), "UTF-8");
} catch (UnsupportedEncodingException ex) {
log.error(
"Unsupported Encoding when updating object in Office 365, path was {0}. Error: {1}",
path, ex);
}
httpPatch.setEntity(postEntity);
HttpClient httpClient = HttpClientBuilder.create().build();
try {
HttpResponse response = httpClient.execute(httpPatch);
HttpEntity entity = response.getEntity();
if (response.getStatusLine().getStatusCode() != 204) {
log.error("An error occured when modify an object in Office 365");
this.invalidateToken();
StringBuffer sb = new StringBuffer();
if (entity != null && entity.getContent() != null) {
BufferedReader in = new BufferedReader(new InputStreamReader(entity.getContent()));
String s = null;
log.info("Response :{0}", response.getStatusLine().toString());
while ((s = in.readLine()) != null) {
sb.append(s);
log.info(s);
}
}
throw new ConnectorException(
"Modify Object failed to "
+ path
+ " and body of "
+ body.toString()
+ ". Error code was "
+ response.getStatusLine().getStatusCode()
+ ". Received the following response "
+ sb.toString());
} else {
return true;
}
} catch (ClientProtocolException cpe) {
log.error(cpe, "Error doing patchRequest to path {0}", path);
throw new ConnectorException("Exception whilst doing PATCH to " + path);
} catch (IOException ioe) {
log.error(ioe, "IOE Error doing patchRequest to path {0}", path);
throw new ConnectorException("Exception whilst doing PATCH to " + path);
}
}