// *****************************************************************************
// Delete Contact using HTTP DELETE method with singleContactUrl.
// *****************************************************************************
public Integer DeleteContact(Contact deleteContact) {
Integer statusCode = 0;
HttpResponse response;
try {
boolean isValid = true;
// Data validation goes here
if (isValid) {
HttpDelete request = new HttpDelete(singleContactUrl + deleteContact.getId());
request.setHeader("User-Agent", "dev.ronlemire.contactClient");
request.setHeader("Accept", "application/json");
request.setHeader("Content-type", "application/json");
// Send request to WCF service
DefaultHttpClient httpClient = new DefaultHttpClient();
response = httpClient.execute(request);
Log.d("WebInvoke", "Saving : " + response.getStatusLine().getStatusCode());
statusCode = response.getStatusLine().getStatusCode();
}
} catch (Exception e) {
e.printStackTrace();
}
return statusCode;
}
@Override
public void deleteItem(final ProxyRepository repository, final ResourceStoreRequest request)
throws ItemNotFoundException, UnsupportedStorageOperationException, RemoteStorageException {
final URL remoteUrl =
appendQueryString(getAbsoluteUrlFromBase(repository, request), repository);
final HttpDelete method = new HttpDelete(remoteUrl.toExternalForm());
final HttpResponse httpResponse = executeRequestAndRelease(repository, request, method);
final int statusCode = httpResponse.getStatusLine().getStatusCode();
if (statusCode != HttpStatus.SC_OK
&& statusCode != HttpStatus.SC_NO_CONTENT
&& statusCode != HttpStatus.SC_ACCEPTED) {
throw new RemoteStorageException(
"The response to HTTP "
+ method.getMethod()
+ " was unexpected HTTP Code "
+ statusCode
+ " : "
+ httpResponse.getStatusLine().getReasonPhrase()
+ " [repositoryId=\""
+ repository.getId()
+ "\", requestPath=\""
+ request.getRequestPath()
+ "\", remoteUrl=\""
+ remoteUrl.toString()
+ "\"]");
}
}
public static String delete(String url, Map<String, String> data)
throws IllegalStateException, ClientProtocolException, HttpResponseException, IOException {
HttpDelete request = null;
if (data == null || data.isEmpty()) {
request = new HttpDelete(url);
} else {
String paramStr = "";
for (Map.Entry<String, String> entry : data.entrySet()) {
paramStr += "&" + entry.getKey() + "=" + entry.getValue();
}
if (url.indexOf("?") == -1) {
url += paramStr.replaceFirst("&", "?");
} else {
url += paramStr;
}
url += "&";
url = encodeSpecCharacters(url);
L.e(url);
request = new HttpDelete(url);
}
request.addHeader("Content-Type", "application/x-www-form-urlencoded");
// support Gzip
supportGzip(request);
return processResponse(httpClient.execute(request));
}
/**
* Synchroniseert verwijderde polygonen met de server
*
* @param group groupid om polygonen uit te syncen
* @throws SyncException
*/
private void deletePolygons(int group) throws SyncException {
Cursor c = db.getRemovedPolygons(group);
int polygonid = 0;
if (!c.moveToFirst()) {
return; // Niks te syncen, dus gelijk klaar!
}
do {
polygonid = c.getInt(0);
HttpDelete httpd = new HttpDelete(serverUrl + "polygon/id/" + polygonid);
UsernamePasswordCredentials creds = new UsernamePasswordCredentials(mappUser, mappPass);
try {
httpd.addHeader(new BasicScheme().authenticate(creds, httpd));
} catch (AuthenticationException e1) {
Log.e(Mapp.TAG, e1.getStackTrace().toString());
throw new SyncException("Authentication failed");
}
HttpResponse response;
try {
response = httpclient.execute(httpd);
if (response.getStatusLine().getStatusCode() == 418) {
throw new SyncException("Unable to synchronize because the server is a teapot.");
} else if (response.getStatusLine().getStatusCode() == 401) {
throw new SyncException("Not authorized");
} else if (response.getStatusLine().getStatusCode() != 200) {
// Er is iets mis gegaan.
// Lees de uitvoer
InputStream is = response.getEntity().getContent();
BufferedReader r = new BufferedReader(new InputStreamReader(is));
StringBuilder total = new StringBuilder();
String line;
while ((line = r.readLine()) != null) {
total.append(line);
}
JSONObject result = null;
result = new JSONObject(total.toString());
Log.e(Mapp.TAG, "Sync error: " + result.getString("message"));
throw new SyncException(result.getString("message"));
} else {
db.removeRemovedPolygon(polygonid);
}
} catch (ClientProtocolException e) {
Log.e(Mapp.TAG, e.getMessage());
throw new SyncException("Epic HTTP failure");
} catch (IOException e) {
Log.e(Mapp.TAG, e.getMessage());
throw new SyncException("Exception during server synchronisation");
} catch (JSONException e) {
Log.e(Mapp.TAG, "Sync failed. Getting status message from JSON response failed.");
throw new SyncException("Invalid server response");
}
} while (c.moveToNext());
}
public DrvLicRepresentation cancel() {
try {
HttpDelete request = new HttpDelete(link.getHref());
request.addHeader("Accept", DrvLicRepresentation.DRVLIC_MEDIA_TYPE);
log.debug("calling {} {}", request.getMethod(), request.getURI());
HttpResponse response = httpClient.execute(request);
result = HttpResult.getResult(Void.class, null, response);
if (result.status >= 200 && result.status <= 299) {
return new DrvLicRepresentation(); // no links
} else {
log.warn(
String.format(
"error calling %s %s, %d:%s",
request.getMethod(), link, result.status, result.errorMsg));
return null;
}
} catch (UnsupportedEncodingException ex) {
throw new RuntimeException(ex);
} catch (IllegalStateException ex) {
ex.printStackTrace();
throw new RuntimeException("State error reading stream", ex);
} catch (IOException ex) {
ex.printStackTrace();
throw new RuntimeException("IO error reading stream", ex);
} catch (JAXBException ex) {
ex.printStackTrace();
throw new RuntimeException("JAXB error demarshalling result", ex);
} finally {
}
}
/**
* 通过delete方式发送请求 删除农场
*
* @param url URL地址
* @param params 参数 user_serial, password, farm_serial
* @return
* @throws Exception
*/
public String httpdeleteFarm(String url, String tokenAuth) throws Exception {
// 拼接请求URL
int timeoutConnection = YunTongXun.httpclienttime;
int timeoutSocket = YunTongXun.httpclienttime;
HttpParams httpParameters =
new BasicHttpParams(); // Set the timeout in milliseconds until a connection is established.
HttpConnectionParams.setConnectionTimeout(
httpParameters,
timeoutConnection); // Set the default socket timeout (SO_TIMEOUT) // in milliseconds which
// is the timeout for waiting for data.
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
// 构造HttpClient的实例
HttpClient httpClient = new DefaultHttpClient(httpParameters);
// 创建GET方法的实例
HttpDelete httpexit = new HttpDelete(url);
httpexit.setHeader("Authorization", tokenAuth);
try {
HttpResponse httpResponse = httpClient.execute(httpexit);
int statusCode = httpResponse.getStatusLine().getStatusCode();
return "{status_code:" + statusCode + "}";
} catch (Exception e) {
return null;
}
}
@Test
public void testDeleteVipCustomer() throws Exception {
HttpDelete delete =
new HttpDelete(
"http://localhost:" + PORT_PATH + "/rest/customerservice/customers/vip/gold/123");
delete.addHeader("Accept", "text/xml");
HttpResponse response = httpclient.execute(delete);
assertEquals(200, response.getStatusLine().getStatusCode());
}
/*.................................................................................................................*/
public void deleteJob(HttpClient httpclient, String URL) {
HttpDelete httpdelete = new HttpDelete(URL);
httpdelete.addHeader("cipres-appkey", CIPRESkey);
try {
HttpResponse response = httpclient.execute(httpdelete);
} catch (IOException e) {
Debugg.printStackTrace(e);
}
}
// TODO: throw all exceptions in the Execute method (or equivalent)
public void Execute(int method) throws UnsupportedEncodingException {
last_method = method;
switch (method) {
case HTTP_GET:
{
HttpGet request = new HttpGet(url + getCombinedParams());
// add headers
for (NameValuePair h : headers) {
request.addHeader(h.getName(), h.getValue());
}
executeRequest(request, url);
break;
}
case HTTP_POST:
{
HttpPost request = new HttpPost(url);
// add headers
for (NameValuePair h : headers) {
request.addHeader(h.getName(), h.getValue());
}
if (!params.isEmpty()) {
request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
}
executeRequest(request, url);
break;
}
case HTTP_PUT:
{
HttpPut request = new HttpPut(url);
// add headers
for (NameValuePair h : headers) {
request.addHeader(h.getName(), h.getValue());
}
if (!params.isEmpty()) {
request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
}
executeRequest(request, url);
break;
}
case HTTP_DELETE:
{
HttpDelete request = new HttpDelete(url + getCombinedParams());
// add headers
for (NameValuePair h : headers) {
request.addHeader(h.getName(), h.getValue());
}
executeRequest(request, url);
break;
}
}
}
/**
* Perform a HTTP DELETE request.
*
* @param context the Android Context which initiated the request.
* @param url the URL to send the request to.
* @param headers set one-time headers for this request
* @param params additional DELETE parameters or files to send along with request
* @param responseHandler the response handler instance that should handle the response.
*/
public RequestHandle delete(
Context context,
String url,
Header[] headers,
RequestParams params,
AsyncHttpResponseHandler responseHandler) {
HttpDelete httpDelete =
new HttpDelete(getUrlWithQueryString(isUrlEncodingEnabled, url, params));
if (headers != null) httpDelete.setHeaders(headers);
return sendRequest(httpClient, httpContext, httpDelete, null, responseHandler, context);
}
public HttpResponse doDelete(URI resourcePath) throws Exception {
HttpDelete httpDelete = null;
try {
httpDelete = new HttpDelete(resourcePath);
httpDelete.addHeader("Content-Type", "application/json");
return httpClient.execute(httpDelete, new HttpResponseHandler());
} finally {
releaseConnection(httpDelete);
}
}
/**
* Sends a POST request and returns the response.
*
* @param endpoint The endpoint to send the request to.
* @param responseClass The class to deserialise the Json response to. Can be null if no response
* message is expected.
* @param headers Any additional headers to send with this request. You can use {@link
* org.apache.http.HttpHeaders} constants for header names.
* @param <T> The type to deserialise the response to.
* @return A {@link Response} containing the deserialised body, if any.
* @throws IOException If an error occurs.
*/
public <T> Response<T> delete(Endpoint endpoint, Class<T> responseClass, NameValuePair... headers)
throws IOException {
// Create the request
HttpDelete delete = new HttpDelete(endpoint.url());
delete.setHeaders(combineHeaders(headers));
// Send the request and process the response
try (CloseableHttpResponse response = httpClient().execute(delete)) {
T body = deserialiseResponseMessage(response, responseClass);
return new Response<>(response.getStatusLine(), body);
}
}
@SuppressWarnings("unused")
private synchronized void doUnRegister(String service) {
String url = registryURL;
try {
HttpDelete method = new HttpDelete(url);
method.addHeader("service", service);
ResponseHandler<String> handler = new BasicResponseHandler();
String responseBody = httpClient.execute(method, handler);
LOG.debug("DELETE to " + url + " got a " + responseBody);
} catch (Exception e) {
LOG.debug("DELETE to " + url + " failed with: " + e);
}
}
public static void deleteMessage(String login, String id) {
HttpClient m_ClientHttp = new DefaultHttpClient();
try {
URI uri = new URI("https", WEB.URL, WEB.DELETE_MESSAGE(login, id), null, null);
HttpDelete requeteDelete = new HttpDelete(uri);
requeteDelete.addHeader("Content-Type", "application/json");
String body = m_ClientHttp.execute(requeteDelete, new BasicResponseHandler());
} catch (Exception e) {
throw new IllegalArgumentException(e.getMessage());
}
}
protected String getData(
String url, String method, String contentType, String content, ContinuationToken cTokens) {
try {
HttpClient client = new DefaultHttpClient();
HttpResponse res = null;
url = url.replaceAll(" ", "%20");
if (method == "GET") {
HttpGet get = new HttpGet(url);
get.addHeader("Authorization", token);
get.addHeader("Content-Type", contentType);
get.addHeader("Content-Length", content.length() + "");
res = client.execute(get);
} else if (method == "POST") {
HttpPost post = new HttpPost(url);
post.addHeader("Authorization", token);
post.addHeader("Content-Type", contentType);
StringEntity entity = new StringEntity(content, HTTP.UTF_8);
post.setEntity(entity);
res = client.execute(post);
} else if (method == "DELETE") {
HttpDelete del = new HttpDelete(url);
del.addHeader("Authorization", token);
del.addHeader("Content-Type", contentType);
res = client.execute(del);
} else if (method == "PUT") {
HttpPut put = new HttpPut(url);
put.addHeader("Authorization", token);
put.addHeader("Content-Type", contentType);
StringEntity entity = new StringEntity(content, HTTP.UTF_8);
put.setEntity(entity);
res = client.execute(put);
}
StatusLine sl = res.getStatusLine();
String json = "";
if (sl.getStatusCode() == HttpStatus.SC_OK) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
res.getEntity().writeTo(out);
out.close();
json = out.toString();
Log.i("result", json);
return json;
} else {
Log.i("error", sl.getReasonPhrase());
}
} catch (IOException ex) {
ex.printStackTrace();
}
return null;
}
private static void delete(final String graph, boolean check)
throws URISyntaxException, ClientProtocolException, IOException {
URI uri = uri(graph);
HttpDelete httpdelete = new HttpDelete(uri);
httpdelete.setHeader("Accept", "text/plain");
HttpResponse response = httpclient.execute(httpdelete);
if (check) {
assertEquals(204, response.getStatusLine().getStatusCode());
}
httpdelete.abort();
}
public boolean deleteRequest(String path) {
log.info("deleteRequest(" + path + ")");
// http://msdn.microsoft.com/en-us/library/windowsazure/dn151676.aspx
HttpDelete httpDelete = new HttpDelete(getAPIEndPoint(path));
httpDelete.addHeader("Authorization", this.getToken());
httpDelete.addHeader("Content-Type", "application/json");
httpDelete.addHeader("DataServiceVersion", "3.0;NetFx");
httpDelete.addHeader("MaxDataServiceVersion", "3.0;NetFx");
HttpClient httpClient = HttpClientBuilder.create().build();
try {
HttpResponse response = httpClient.execute(httpDelete);
HttpEntity entity = response.getEntity();
if (response.getStatusLine().getStatusCode() != 204) {
log.error("An error occured when deleting 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(
"Delete Object failed to "
+ path
+ ". Error code was "
+ response.getStatusLine().getStatusCode()
+ ". Received the following response "
+ sb.toString());
} else {
return true;
}
} catch (ClientProtocolException cpe) {
log.error(cpe, "Error doing deleteRequest to path {0}", path);
throw new ConnectorException("Exception whilst doing DELETE to " + path);
} catch (IOException ioe) {
log.error(ioe, "IOE Error doing deleteRequest to path {0}", path);
throw new ConnectorException("Exception whilst doing DELETE to " + path);
}
}
/**
* Deletes OAuth Client from Authorization Server.
*
* @param consumerKey consumer key of the OAuth Client.
* @throws APIManagementException
*/
@Override
public void deleteApplication(String consumerKey) throws APIManagementException {
LOGGER.log(
Level.INFO, "OAuthTwoClient - deleteApplication: " + consumerKey + " will be deleted.");
Long id = nameIdMapping.get(consumerKey);
String configURL = configuration.getParameter(OAuthTwoConstants.CLIENT_REG_ENDPOINT);
String configURLsAccessToken =
configuration.getParameter(OAuthTwoConstants.REGISTRAION_ACCESS_TOKEN);
HttpClient client = getHttpClient();
try {
// Deletion has to be called providing the ID. If we don't have the
// ID we can't proceed with Delete.
if (id != null) {
configURL += "/" + id.toString();
HttpDelete httpDelete = new HttpDelete(configURL);
LOGGER.log(
Level.INFO, "OAuthTwoClient - deleteApplication: id:" + id + " URL:" + configURL);
// Set Authorization Header
httpDelete.addHeader(
OAuthTwoConstants.AUTHORIZATION, OAuthTwoConstants.BEARER + configURLsAccessToken);
HttpResponse response = client.execute(httpDelete);
int responseCode = response.getStatusLine().getStatusCode();
LOGGER.log(Level.INFO, "Delete application response code : " + responseCode);
if (responseCode == HttpStatus.SC_OK || responseCode == HttpStatus.SC_NO_CONTENT) {
LOGGER.log(
Level.INFO,
"OAuth Client for consumer Id " + consumerKey + " has been successfully deleted");
nameIdMapping.remove(consumerKey);
} else {
handleException("Problem occurred while deleting client for Consumer Key " + consumerKey);
}
}
} catch (IOException e) {
handleException("Error while reading response body from Server ", e);
} finally {
client.getConnectionManager().shutdown();
}
}
public HttpResponse delete(
String cType,
String accountSid,
String authToken,
String timestamp,
String url,
DefaultHttpClient httpclient,
EncryptUtil encryptUtil)
throws Exception {
HttpDelete httpDelete = new HttpDelete(url);
httpDelete.setHeader("Accept", cType);
httpDelete.setHeader("Content-Type", cType + ";charset=utf-8");
String src = accountSid + ":" + timestamp;
String auth = encryptUtil.base64Encoder(src);
httpDelete.setHeader("Authorization", auth);
HttpResponse response = httpclient.execute(httpDelete);
return response;
}
/**
* Takes the extracted base URI and parameters from the {@link RequestConfig} consolidated
* parameter type and creates a {@link HttpRequestBase} of the designated method type.
*
* @param uri the {@link URI} whose parameters should be populated
* @param annotatedParams the list of {@link Param}s and the parameter objects which were
* annotated with them; <b>Complex objects should supply a formatted version of their String
* representation via {@link Object#toString()}</b>
* @param staticParams the list of {@link Request.Param}s and the parameter objects which were
* annotated with them <br>
* <br>
* @return the created {@link HttpRequestBase} which is an instance of {@link HttpPost} <br>
* <br>
* @throws Exception when the {@link HttpRequestBase} could not be created due to an exception
* <br>
* <br>
* @since 1.1.3
*/
private static HttpRequestBase populateDeleteParameters(
URI uri, Map<Object, Param> annotatedParams, List<Request.Param> staticParams)
throws Exception {
HttpParams httpParams = new BasicHttpParams();
for (Request.Param param : staticParams) httpParams.setParameter(param.name(), param.value());
Set<Entry<Object, Param>> methodParams = annotatedParams.entrySet();
for (Entry<Object, Param> entry : methodParams)
httpParams.setParameter(entry.getValue().value(), entry.getKey().toString());
HttpDelete httpDelete = new HttpDelete(uri);
httpDelete.setParams(httpParams);
return httpDelete;
}
/**
* This class deletes the interest. The Http Client sends an HTTP DEL request to the API to delete
* the interest. The API sends information which is stored in Android via JSON to the webserver.
*
* @throws JSONException
* @throws ClientProtocolException
* @throws IOException
*/
public void deleteInterest() throws JSONException, ClientProtocolException, IOException {
HttpClient client = new DefaultHttpClient();
HttpDelete del =
new HttpDelete(
"http://myapp-gosuninjas.dotcloud.com/api/v1/createinterest/"
+ UserProfile.interestpoint
+ "/");
del.setHeader("Content-type", "application/json");
del.setHeader("Content-Length", "0");
try {
HttpResponse response = client.execute(del);
} catch (ClientProtocolException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
@Override
public String delete(String token, String said) throws ServiceNotAvailableException {
HttpDelete httpDelete = new HttpDelete(serviceEnpoint + "?said=" + said);
String encode = Base64.encodeBase64String((said + ":" + token).getBytes());
httpDelete.addHeader("Authorization", "Basic " + encode.replace("\r\n", ""));
HttpResponse response;
try {
response = httpClient.execute(httpDelete);
HttpEntity entity = response.getEntity();
if (entity != null) {
String jsonResponse = IOUtils.toString(entity.getContent());
logger.debug("Register response: {}", jsonResponse);
return jsonResponse;
}
} catch (Exception e) {
throw new ServiceNotAvailableException("Unable to register");
}
return null;
}
@Override
public String deleteGet(String url) {
int responseCode = -1;
HttpClient httpClient = new DefaultHttpClient();
StringBuffer responseOutput = new StringBuffer();
try {
HttpDelete request = new HttpDelete(url);
request.addHeader("content-type", "application/json");
HttpResponse response = httpClient.execute(request);
responseCode = response.getStatusLine().getStatusCode();
if (responseCode == 200 || responseCode == 204) {
if (response.getEntity() != null) {
BufferedReader br =
new BufferedReader(new InputStreamReader((response.getEntity().getContent())));
String output;
while ((output = br.readLine()) != null) {
responseOutput.append(output);
}
}
} else {
logger.error("Failed : HTTP error code : " + response.getStatusLine().getStatusCode());
throw new RuntimeException(
"Failed : HTTP error code : " + response.getStatusLine().getStatusCode());
}
} catch (Exception ex) {
logger.error("exception for url = " + url);
logger.error(elog.toStringException(ex));
} finally {
httpClient.getConnectionManager().shutdown();
}
if (responseCode == -1) {
return "Exception";
}
return responseOutput.toString();
}
/* Delete the file used to test savePhoto() after the testcase has run */
public void tearDown() throws Exception {
/* Delete the story added to online */
@SuppressWarnings("resource")
HttpClient httpclient = new DefaultHttpClient();
HttpDelete httpDelete =
new HttpDelete("http://cmput301.softwareprocess.es:8080/cmput301f13t08/stories/" + 100);
httpDelete.addHeader("Accept", "application/json");
HttpResponse response = httpclient.execute(httpDelete);
String status = response.getStatusLine().toString();
System.out.println(status);
HttpEntity entity = response.getEntity();
BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent()));
String output;
System.err.println("Output from Server -> ");
while ((output = br.readLine()) != null) {
System.err.println(output);
}
testActivity.getApplicationContext().deleteFile("Download15");
}
public String delete(String url, Map<String, String> headers)
throws ClientProtocolException, IOException, AuthorizationDeniedException {
// create request
HttpDelete request = new HttpDelete(url);
if (logger.isDebugEnabled()) {
logger.debug("getting url: " + url);
}
// add headers to request
if (headers != null && headers.size() > 0) {
for (String header : headers.keySet()) {
String value = headers.get(header);
request.addHeader(header, value);
if (logger.isDebugEnabled()) {
logger.debug("adding header: " + header + " = " + value);
}
}
}
return process(request);
}
/**
* This method is used to delete all Instagram subscription.<br>
* It used when we call to stop method.
*/
public void deleteSubscription() {
DefaultHttpClient client = new DefaultHttpClient();
String url =
"https://api.instagram.com/v1/subscriptions?object=all&client_id="
+ this.clientId
+ "&client_secret="
+ this.clientSecret;
HttpDelete delete = new HttpDelete(url);
try {
log.debug("Delete : " + delete + "Header = " + delete.getAllHeaders());
HttpResponse response = client.execute(delete);
log.info("-----> Delete response :" + response);
} catch (ClientProtocolException e) {
log.error(" Error in client Protocol, error type : " + e);
} catch (IOException e) {
log.error(" Error IO, error type :" + e);
}
}
public void doDelete(String url) throws ClientProtocolException, IOException {
HttpClient httpclient = new DefaultHttpClient();
HttpDelete delete = new HttpDelete(url);
delete.addHeader("accept", "application/json");
httpclient.execute(delete);
}
/**
* Perform a HTTP DELETE request.
*
* @param context the Android Context which initiated the request.
* @param url the URL to send the request to.
* @param headers set one-time headers for this request
* @param responseHandler the response handler instance that should handle the response.
*/
public void delete(
Context context, String url, Header[] headers, AsyncHttpResponseHandler responseHandler) {
final HttpDelete delete = new HttpDelete(url);
if (headers != null) delete.setHeaders(headers);
sendRequest(httpClient, httpContext, delete, null, responseHandler, context);
}
public static void setParameter(HttpDelete delete) {
delete.setParams(HTTPBuilder.getHttpParams());
}
@Override
public void onTrigger(final ProcessContext context, final ProcessSession session) {
final boolean sendAsFlowFile = context.getProperty(SEND_AS_FLOWFILE).asBoolean();
final int compressionLevel = context.getProperty(COMPRESSION_LEVEL).asInteger();
final String userAgent = context.getProperty(USER_AGENT).getValue();
final RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
requestConfigBuilder.setConnectionRequestTimeout(
context.getProperty(DATA_TIMEOUT).asTimePeriod(TimeUnit.MILLISECONDS).intValue());
requestConfigBuilder.setConnectTimeout(
context.getProperty(CONNECTION_TIMEOUT).asTimePeriod(TimeUnit.MILLISECONDS).intValue());
requestConfigBuilder.setRedirectsEnabled(false);
requestConfigBuilder.setSocketTimeout(
context.getProperty(DATA_TIMEOUT).asTimePeriod(TimeUnit.MILLISECONDS).intValue());
final RequestConfig requestConfig = requestConfigBuilder.build();
final StreamThrottler throttler = throttlerRef.get();
final ProcessorLog logger = getLogger();
final Double maxBatchBytes = context.getProperty(MAX_BATCH_SIZE).asDataSize(DataUnit.B);
String lastUrl = null;
long bytesToSend = 0L;
final List<FlowFile> toSend = new ArrayList<>();
DestinationAccepts destinationAccepts = null;
CloseableHttpClient client = null;
final String transactionId = UUID.randomUUID().toString();
final ObjectHolder<String> dnHolder = new ObjectHolder<>("none");
while (true) {
FlowFile flowFile = session.get();
if (flowFile == null) {
break;
}
final String url = context.getProperty(URL).evaluateAttributeExpressions(flowFile).getValue();
try {
new java.net.URL(url);
} catch (final MalformedURLException e) {
logger.error(
"After substituting attribute values for {}, URL is {}; this is not a valid URL, so routing to failure",
new Object[] {flowFile, url});
flowFile = session.penalize(flowFile);
session.transfer(flowFile, REL_FAILURE);
continue;
}
// If this FlowFile doesn't have the same url, throw it back on the queue and stop grabbing
// FlowFiles
if (lastUrl != null && !lastUrl.equals(url)) {
session.transfer(flowFile);
break;
}
lastUrl = url;
toSend.add(flowFile);
if (client == null || destinationAccepts == null) {
final Config config = getConfig(url, context);
final HttpClientConnectionManager conMan = config.getConnectionManager();
final HttpClientBuilder clientBuilder = HttpClientBuilder.create();
clientBuilder.setConnectionManager(conMan);
clientBuilder.setUserAgent(userAgent);
clientBuilder.addInterceptorFirst(
new HttpResponseInterceptor() {
@Override
public void process(final HttpResponse response, final HttpContext httpContext)
throws HttpException, IOException {
HttpCoreContext coreContext = HttpCoreContext.adapt(httpContext);
ManagedHttpClientConnection conn =
coreContext.getConnection(ManagedHttpClientConnection.class);
if (!conn.isOpen()) {
return;
}
SSLSession sslSession = conn.getSSLSession();
if (sslSession != null) {
final X509Certificate[] certChain = sslSession.getPeerCertificateChain();
if (certChain == null || certChain.length == 0) {
throw new SSLPeerUnverifiedException("No certificates found");
}
final X509Certificate cert = certChain[0];
dnHolder.set(cert.getSubjectDN().getName().trim());
}
}
});
clientBuilder.disableAutomaticRetries();
clientBuilder.disableContentCompression();
final String username = context.getProperty(USERNAME).getValue();
final String password = context.getProperty(PASSWORD).getValue();
// set the credentials if appropriate
if (username != null) {
final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
if (password == null) {
credentialsProvider.setCredentials(
AuthScope.ANY, new UsernamePasswordCredentials(username));
} else {
credentialsProvider.setCredentials(
AuthScope.ANY, new UsernamePasswordCredentials(username, password));
}
clientBuilder.setDefaultCredentialsProvider(credentialsProvider);
}
client = clientBuilder.build();
// determine whether or not destination accepts flowfile/gzip
destinationAccepts = config.getDestinationAccepts();
if (destinationAccepts == null) {
try {
if (sendAsFlowFile) {
destinationAccepts =
getDestinationAcceptance(client, url, getLogger(), transactionId);
} else {
destinationAccepts = new DestinationAccepts(false, false, false, false, null);
}
config.setDestinationAccepts(destinationAccepts);
} catch (IOException e) {
flowFile = session.penalize(flowFile);
session.transfer(flowFile, REL_FAILURE);
logger.error(
"Unable to communicate with destination {} to determine whether or not it can accept "
+ "flowfiles/gzip; routing {} to failure due to {}",
new Object[] {url, flowFile, e});
context.yield();
return;
}
}
}
// if we are not sending as flowfile, or if the destination doesn't accept V3 or V2
// (streaming) format,
// then only use a single FlowFile
if (!sendAsFlowFile
|| (!destinationAccepts.isFlowFileV3Accepted()
&& !destinationAccepts.isFlowFileV2Accepted())) {
break;
}
bytesToSend += flowFile.getSize();
if (bytesToSend > maxBatchBytes.longValue()) {
break;
}
}
if (toSend.isEmpty()) {
return;
}
final String url = lastUrl;
final HttpPost post = new HttpPost(url);
final List<FlowFile> flowFileList = toSend;
final DestinationAccepts accepts = destinationAccepts;
final boolean isDestinationLegacyNiFi = accepts.getProtocolVersion() == null;
final EntityTemplate entity =
new EntityTemplate(
new ContentProducer() {
@Override
public void writeTo(final OutputStream rawOut) throws IOException {
final OutputStream throttled =
(throttler == null) ? rawOut : throttler.newThrottledOutputStream(rawOut);
OutputStream wrappedOut = new BufferedOutputStream(throttled);
if (compressionLevel > 0 && accepts.isGzipAccepted()) {
wrappedOut = new GZIPOutputStream(wrappedOut, compressionLevel);
}
try (final OutputStream out = wrappedOut) {
for (final FlowFile flowFile : flowFileList) {
session.read(
flowFile,
new InputStreamCallback() {
@Override
public void process(final InputStream rawIn) throws IOException {
try (final InputStream in = new BufferedInputStream(rawIn)) {
FlowFilePackager packager = null;
if (!sendAsFlowFile) {
packager = null;
} else if (accepts.isFlowFileV3Accepted()) {
packager = new FlowFilePackagerV3();
} else if (accepts.isFlowFileV2Accepted()) {
packager = new FlowFilePackagerV2();
} else if (accepts.isFlowFileV1Accepted()) {
packager = new FlowFilePackagerV1();
}
// if none of the above conditions is met, we should never get here,
// because
// we will have already verified that at least 1 of the FlowFile
// packaging
// formats is acceptable if sending as FlowFile.
if (packager == null) {
StreamUtils.copy(in, out);
} else {
final Map<String, String> flowFileAttributes;
if (isDestinationLegacyNiFi) {
// Old versions of NiFi expect nf.file.name and nf.file.path to
// indicate filename & path;
// in order to maintain backward compatibility, we copy the
// filename & path to those attribute keys.
flowFileAttributes = new HashMap<>(flowFile.getAttributes());
flowFileAttributes.put(
"nf.file.name",
flowFile.getAttribute(CoreAttributes.FILENAME.key()));
flowFileAttributes.put(
"nf.file.path",
flowFile.getAttribute(CoreAttributes.PATH.key()));
} else {
flowFileAttributes = flowFile.getAttributes();
}
packager.packageFlowFile(
in, out, flowFileAttributes, flowFile.getSize());
}
}
}
});
}
out.flush();
}
}
});
entity.setChunked(context.getProperty(CHUNKED_ENCODING).asBoolean());
post.setEntity(entity);
post.setConfig(requestConfig);
final String contentType;
if (sendAsFlowFile) {
if (accepts.isFlowFileV3Accepted()) {
contentType = APPLICATION_FLOW_FILE_V3;
} else if (accepts.isFlowFileV2Accepted()) {
contentType = APPLICATION_FLOW_FILE_V2;
} else if (accepts.isFlowFileV1Accepted()) {
contentType = APPLICATION_FLOW_FILE_V1;
} else {
logger.error(
"Cannot send data to {} because the destination does not accept FlowFiles and this processor is "
+ "configured to deliver FlowFiles; rolling back session",
new Object[] {url});
session.rollback();
context.yield();
return;
}
} else {
final String attributeValue = toSend.get(0).getAttribute(CoreAttributes.MIME_TYPE.key());
contentType = (attributeValue == null) ? DEFAULT_CONTENT_TYPE : attributeValue;
}
final String attributeHeaderRegex = context.getProperty(ATTRIBUTES_AS_HEADERS_REGEX).getValue();
if (attributeHeaderRegex != null && !sendAsFlowFile && flowFileList.size() == 1) {
final Pattern pattern = Pattern.compile(attributeHeaderRegex);
final Map<String, String> attributes = flowFileList.get(0).getAttributes();
for (final Map.Entry<String, String> entry : attributes.entrySet()) {
final String key = entry.getKey();
if (pattern.matcher(key).matches()) {
post.setHeader(entry.getKey(), entry.getValue());
}
}
}
post.setHeader(CONTENT_TYPE, contentType);
post.setHeader(FLOWFILE_CONFIRMATION_HEADER, "true");
post.setHeader(PROTOCOL_VERSION_HEADER, PROTOCOL_VERSION);
post.setHeader(TRANSACTION_ID_HEADER, transactionId);
if (compressionLevel > 0 && accepts.isGzipAccepted()) {
post.setHeader(GZIPPED_HEADER, "true");
}
// Do the actual POST
final String flowFileDescription =
toSend.size() <= 10 ? toSend.toString() : toSend.size() + " FlowFiles";
final String uploadDataRate;
final long uploadMillis;
CloseableHttpResponse response = null;
try {
final StopWatch stopWatch = new StopWatch(true);
response = client.execute(post);
// consume input stream entirely, ignoring its contents. If we
// don't do this, the Connection will not be returned to the pool
EntityUtils.consume(response.getEntity());
stopWatch.stop();
uploadDataRate = stopWatch.calculateDataRate(bytesToSend);
uploadMillis = stopWatch.getDuration(TimeUnit.MILLISECONDS);
} catch (final IOException e) {
logger.error(
"Failed to Post {} due to {}; transferring to failure",
new Object[] {flowFileDescription, e});
context.yield();
for (FlowFile flowFile : toSend) {
flowFile = session.penalize(flowFile);
session.transfer(flowFile, REL_FAILURE);
}
return;
} finally {
if (response != null) {
try {
response.close();
} catch (IOException e) {
getLogger().warn("Failed to close HTTP Response due to {}", new Object[] {e});
}
}
}
// If we get a 'SEE OTHER' status code and an HTTP header that indicates that the intent
// of the Location URI is a flowfile hold, we will store this holdUri. This prevents us
// from posting to some other webservice and then attempting to delete some resource to which
// we are redirected
final int responseCode = response.getStatusLine().getStatusCode();
final String responseReason = response.getStatusLine().getReasonPhrase();
String holdUri = null;
if (responseCode == HttpServletResponse.SC_SEE_OTHER) {
final Header locationUriHeader = response.getFirstHeader(LOCATION_URI_INTENT_NAME);
if (locationUriHeader != null) {
if (LOCATION_URI_INTENT_VALUE.equals(locationUriHeader.getValue())) {
final Header holdUriHeader = response.getFirstHeader(LOCATION_HEADER_NAME);
if (holdUriHeader != null) {
holdUri = holdUriHeader.getValue();
}
}
}
if (holdUri == null) {
for (FlowFile flowFile : toSend) {
flowFile = session.penalize(flowFile);
logger.error(
"Failed to Post {} to {}: sent content and received status code {}:{} but no Hold URI",
new Object[] {flowFile, url, responseCode, responseReason});
session.transfer(flowFile, REL_FAILURE);
}
return;
}
}
if (holdUri == null) {
if (responseCode == HttpServletResponse.SC_SERVICE_UNAVAILABLE) {
for (FlowFile flowFile : toSend) {
flowFile = session.penalize(flowFile);
logger.error(
"Failed to Post {} to {}: response code was {}:{}; will yield processing, "
+ "since the destination is temporarily unavailable",
new Object[] {flowFile, url, responseCode, responseReason});
session.transfer(flowFile, REL_FAILURE);
}
context.yield();
return;
}
if (responseCode >= 300) {
for (FlowFile flowFile : toSend) {
flowFile = session.penalize(flowFile);
logger.error(
"Failed to Post {} to {}: response code was {}:{}",
new Object[] {flowFile, url, responseCode, responseReason});
session.transfer(flowFile, REL_FAILURE);
}
return;
}
logger.info(
"Successfully Posted {} to {} in {} at a rate of {}",
new Object[] {
flowFileDescription,
url,
FormatUtils.formatMinutesSeconds(uploadMillis, TimeUnit.MILLISECONDS),
uploadDataRate
});
for (final FlowFile flowFile : toSend) {
session
.getProvenanceReporter()
.send(flowFile, url, "Remote DN=" + dnHolder.get(), uploadMillis, true);
session.transfer(flowFile, REL_SUCCESS);
}
return;
}
//
// the response indicated a Hold URI; delete the Hold.
//
// determine the full URI of the Flow File's Hold; Unfortunately, the responses that are
// returned have
// changed over the past, so we have to take into account a few different possibilities.
String fullHoldUri = holdUri;
if (holdUri.startsWith("/contentListener")) {
// If the Hold URI that we get starts with /contentListener, it may not really be
// /contentListener,
// as this really indicates that it should be whatever we posted to -- if posting directly to
// the
// ListenHTTP component, it will be /contentListener, but if posting to a proxy/load balancer,
// we may
// be posting to some other URL.
fullHoldUri = url + holdUri.substring(16);
} else if (holdUri.startsWith("/")) {
// URL indicates the full path but not hostname or port; use the same hostname & port that we
// posted
// to but use the full path indicated by the response.
int firstSlash = url.indexOf("/", 8);
if (firstSlash < 0) {
firstSlash = url.length();
}
final String beforeSlash = url.substring(0, firstSlash);
fullHoldUri = beforeSlash + holdUri;
} else if (!holdUri.startsWith("http")) {
// Absolute URL
fullHoldUri = url + (url.endsWith("/") ? "" : "/") + holdUri;
}
final HttpDelete delete = new HttpDelete(fullHoldUri);
delete.setHeader(TRANSACTION_ID_HEADER, transactionId);
while (true) {
try {
final HttpResponse holdResponse = client.execute(delete);
EntityUtils.consume(holdResponse.getEntity());
final int holdStatusCode = holdResponse.getStatusLine().getStatusCode();
final String holdReason = holdResponse.getStatusLine().getReasonPhrase();
if (holdStatusCode >= 300) {
logger.error(
"Failed to delete Hold that destination placed on {}: got response code {}:{}; routing to failure",
new Object[] {flowFileDescription, holdStatusCode, holdReason});
for (FlowFile flowFile : toSend) {
flowFile = session.penalize(flowFile);
session.transfer(flowFile, REL_FAILURE);
}
return;
}
logger.info(
"Successfully Posted {} to {} in {} milliseconds at a rate of {}",
new Object[] {flowFileDescription, url, uploadMillis, uploadDataRate});
for (FlowFile flowFile : toSend) {
session.getProvenanceReporter().send(flowFile, url);
session.transfer(flowFile, REL_SUCCESS);
}
return;
} catch (final IOException e) {
logger.warn(
"Failed to delete Hold that destination placed on {} due to {}",
new Object[] {flowFileDescription, e});
}
if (!isScheduled()) {
context.yield();
logger.warn(
"Failed to delete Hold that destination placed on {}; Processor has been stopped so routing FlowFile(s) to failure",
new Object[] {flowFileDescription});
for (FlowFile flowFile : toSend) {
flowFile = session.penalize(flowFile);
session.transfer(flowFile, REL_FAILURE);
}
return;
}
}
}