Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 tamtam180
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.arangodb.http;
 
 import java.util.List;
 import java.util.Map;
 
 

Author(s):
tamtam180 - kirscheless at gmail.com
a-brandt
 
 public class HttpManager {
 
 	private static final ContentType APPLICATION_JSON_UTF8 = ContentType.create("application/json""utf-8");
 
 	private static Logger logger = LoggerFactory.getLogger(HttpManager.class);
 
 
 
 
 	private HttpMode httpMode = .;
 
 	private List<StringjobIds = new ArrayList<String>();
 
 
 	public static enum HttpMode {
 		SYNC,
 		ASYNC,
		FIREANDFORGET
	}
	public HttpManager(ArangoConfigure configure) {
		this. = configure;
	}
		return this.;
	}
	public void init() {
		// ConnectionManager
		Builder custom = RequestConfig.custom();
		// RequestConfig
		}
		if (.getTimeout() >= 0) {
		}
		RequestConfig requestConfig = custom.build();
		HttpClientBuilder builder = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig);
		// KeepAlive Strategy
			public long getKeepAliveDuration(HttpResponse responseHttpContext context) {
				// Honor 'keep-alive' header
				while (it.hasNext()) {
					String param = he.getName();
					String value = he.getValue();
					if (value != null && param.equalsIgnoreCase("timeout")) {
						try {
							return Long.parseLong(value) * 1000;
catch (NumberFormatException ignore) {
						}
					}
				}
				// otherwise keep alive for 30 seconds
				return 30 * 1000;
			}
		};
		builder.setKeepAliveStrategy(keepAliveStrategy);
		// Retry Handler
		// Proxy
		if (.getProxyHost() != null && .getProxyPort() != 0) {
			builder.setRoutePlanner(routePlanner);
		}
		// Client
		 = builder.build();
		// Basic Auth
		// if (configure.getUser() != null && configure.getPassword() != null) {
		// AuthScope scope = AuthScope.ANY; // TODO
		// this.credentials = new
		// UsernamePasswordCredentials(configure.getUser(),
		// configure.getPassword());
		// client.getCredentialsProvider().setCredentials(scope, credentials);
		// }
	}
	public void destroy() {
		if ( != null) {
		}
		 = null;
	}
	public HttpMode getHttpMode() {
		return ;
	}
	public void setHttpMode(HttpMode httpMode) {
		this. = httpMode;
	}
		return doGet(urlnull);
	}
	public HttpResponseEntity doGet(String urlMap<StringObjectparamsthrows ArangoException {
		return doHeadGetDelete(.urlnullparams);
	}
	public HttpResponseEntity doGet(String urlMap<StringObjectheadersMap<StringObjectparams)
			throws ArangoException {
		return doHeadGetDelete(.urlheadersparams);
	}
		String url,
		Map<StringObjectheaders,
		Map<StringObjectparams,
		String username,
		String passwordthrows ArangoException {
		return doHeadGetDelete(.urlheadersparamsusernamepassword);
	}
	public HttpResponseEntity doHead(String urlMap<StringObjectparamsthrows ArangoException {
		return doHeadGetDelete(.urlnullparams);
	}
	public HttpResponseEntity doDelete(String urlMap<StringObjectparamsthrows ArangoException {
		return doHeadGetDelete(.urlnullparams);
	}
	public HttpResponseEntity doDelete(String urlMap<StringObjectheadersMap<StringObjectparams)
			throws ArangoException {
		return doHeadGetDelete(.urlheadersparams);
	}
		String url,
		Map<StringObjectheaders,
		Map<StringObjectparamsthrows ArangoException {
		return doHeadGetDelete(typeurlheadersparamsnullnull);
	}
		String url,
		Map<StringObjectheaders,
		Map<StringObjectparams,
		String username,
		String passwordthrows ArangoException {
		HttpRequestEntity requestEntity = new HttpRequestEntity();
		requestEntity.type = type;
		requestEntity.url = url;
		requestEntity.headers = headers;
		requestEntity.parameters = params;
		requestEntity.username = username;
		requestEntity.password = password;
		return execute(requestEntity);
	}
		String url,
		Map<StringObjectheaders,
		Map<StringObjectparams,
		String bodyTextthrows ArangoException {
		return doPostPutPatch(.urlheadersparamsbodyTextnull);
	}
	public HttpResponseEntity doPost(String urlMap<StringObjectparamsString bodyTextthrows ArangoException {
		return doPostPutPatch(.urlnullparamsbodyTextnull);
	}
	public HttpResponseEntity doPost(String urlMap<StringObjectparamsHttpEntity entitythrows ArangoException {
		return doPostPutPatch(.urlnullparamsnullentity);
	}
		String url,
		Map<StringObjectparams,
		HttpEntity entity,
		Map<StringObjectheaders,
		String bodythrows ArangoException {
		return doPostPutPatch(.urlheadersparamsbodyentity);
	}
	public HttpResponseEntity doPut(String urlMap<StringObjectheadersMap<StringObjectparamsString bodyText)
			throws ArangoException {
		return doPostPutPatch(.urlheadersparamsbodyTextnull);
	}
	public HttpResponseEntity doPut(String urlMap<StringObjectparamsString bodyTextthrows ArangoException {
		return doPostPutPatch(.urlnullparamsbodyTextnull);
	}
		String url,
		Map<StringObjectheaders,
		Map<StringObjectparams,
		String bodyTextthrows ArangoException {
		return doPostPutPatch(.urlheadersparamsbodyTextnull);
	}
	public HttpResponseEntity doPatch(String urlMap<StringObjectparamsString bodyTextthrows ArangoException {
		return doPostPutPatch(.urlnullparamsbodyTextnull);
	}
		String url,
		Map<StringObjectheaders,
		Map<StringObjectparams,
		String bodyText,
		HttpEntity entitythrows ArangoException {
		HttpRequestEntity requestEntity = new HttpRequestEntity();
		requestEntity.type = type;
		requestEntity.url = url;
		requestEntity.headers = headers;
		requestEntity.parameters = params;
		requestEntity.bodyText = bodyText;
		requestEntity.entity = entity;
		return execute(requestEntity);
	}

Executes the request and handles connect exceptions

Parameters:
requestEntity the request
Returns:
the response of the request
Throws:
com.arangodb.ArangoException
	public HttpResponseEntity execute(HttpRequestEntity requestEntitythrows ArangoException {
		int retries = 0;
		int connectRetryCount = .getConnectRetryCount();
		while (true) {
			try {
				return executeInternal(.getBaseUrl(), requestEntity);
catch (SocketException ex) {
				retries++;
				if (connectRetryCount > 0 && retries > connectRetryCount) {
					throw new ArangoException(ex);
				}
				}
				try {
					// 1000 milliseconds is one second.
catch (InterruptedException iex) {
				}
			}
		}
	}

Executes the request

Parameters:
requestEntity the request
Returns:
the response of the request
Throws:
com.arangodb.ArangoException
	private HttpResponseEntity executeInternal(String baseUrlHttpRequestEntity requestEntitythrows ArangoException,
		String url = buildUrl(baseUrlrequestEntity);
			if (requestEntity.type == . || requestEntity.type == .
					|| requestEntity.type == .) {
				.debug("[REQ]http-{}: url={}, headers={}, body={}"new Object[] { requestEntity.typeurl,
						requestEntity.headersrequestEntity.bodyText });
else {
				.debug("[REQ]http-{}: url={}, headers={}"new Object[] { requestEntity.typeurl,
						requestEntity.headers });
			}
		}
		HttpRequestBase request = null;
		switch (requestEntity.type) {
		case :
			request = new HttpGet(url);
			break;
		case :
			HttpPost post = new HttpPost(url);
			configureBodyParams(requestEntitypost);
			request = post;
			break;
		case :
			HttpPut put = new HttpPut(url);
			configureBodyParams(requestEntityput);
			request = put;
			break;
		case :
			HttpPatch patch = new HttpPatch(url);
			configureBodyParams(requestEntitypatch);
			request = patch;
			break;
		case :
			request = new HttpHead(url);
			break;
		case :
			request = new HttpDelete(url);
			break;
		}
		// common-header
		String userAgent = "Mozilla/5.0 (compatible; ArangoDB-JavaDriver/1.1; +http://mt.orz.at/)";
		request.setHeader("User-Agent"userAgent);
		// optinal-headers
		if (requestEntity.headers != null) {
			for (Entry<StringObjectkeyValue : requestEntity.headers.entrySet()) {
				request.setHeader(keyValue.getKey(), keyValue.getValue().toString());
			}
		}
		// Basic Auth
		Credentials credentials = null;
		if (requestEntity.username != null && requestEntity.password != null) {
			credentials = new UsernamePasswordCredentials(requestEntity.usernamerequestEntity.password);
else if (.getUser() != null && .getPassword() != null) {
		}
		if (credentials != null) {
			BasicScheme basicScheme = new BasicScheme();
			try {
				request.addHeader(basicScheme.authenticate(credentialsrequestnull));
catch (AuthenticationException e) {
				throw new ArangoException(e);
			}
		}
			request.addHeader("x-arango-async""store");
else if (this.getHttpMode().equals(.)) {
			request.addHeader("x-arango-async""true");
		}
		// CURL/httpie Logger
			CURLLogger.log(urlrequestEntityuserAgentcredentials);
		}
		HttpResponse response = null;
		if ( != null) {
		}
		try {
			response = .execute(request);
			if (response == null) {
				return null;
			}
			HttpResponseEntity responseEntity = new HttpResponseEntity();
			// http status
			StatusLine status = response.getStatusLine();
			responseEntity.statusCode = status.getStatusCode();
			responseEntity.statusPhrase = status.getReasonPhrase();
			.debug("[RES]http-{}: statusCode={}"requestEntity.typeresponseEntity.statusCode);
			// ヘッダの処理
			// // TODO etag特殊処理は削除する。
			Header etagHeader = response.getLastHeader("etag");
			if (etagHeader != null) {
				responseEntity.etag = Long.parseLong(etagHeader.getValue().replace("\""""));
			}
			// ヘッダをMapに変換する
			responseEntity.headers = new TreeMap<StringString>();
			for (Header header : response.getAllHeaders()) {
				responseEntity.headers.put(header.getName(), header.getValue());
			}
			// レスポンスの取得
			HttpEntity entity = response.getEntity();
			if (entity != null) {
				Header contentType = entity.getContentType();
				if (contentType != null) {
					responseEntity.contentType = contentType.getValue();
					if (responseEntity.isDumpResponse()) {
						responseEntity.stream = entity.getContent();
						.debug("[RES]http-{}: stream, {}"requestEntity.typecontentType.getValue());
					}
				}
				// Close stream in this method.
				if (responseEntity.stream == null) {
					responseEntity.text = IOUtils.toString(entity.getContent());
					.debug("[RES]http-{}: text={}"requestEntity.typeresponseEntity.text);
				}
			}
				Map<StringStringmap = responseEntity.getHeaders();
				this.addJob(map.get("X-Arango-Async-Id"), this.getCurrentObject());
else if (this.getHttpMode().equals(.)) {
				return null;
			}
			return responseEntity;
catch (SocketException ex) {
			throw ex;
catch (ClientProtocolException e) {
			throw new ArangoException(e);
catch (IOException e) {
			throw new ArangoException(e);
		}
	}
	public static String buildUrl(String baseUrlHttpRequestEntity requestEntity) {
		if (requestEntity.parameters != null && !requestEntity.parameters.isEmpty()) {
			String paramString = URLEncodedUtils.format(toList(requestEntity.parameters), "utf-8");
			if (requestEntity.url.contains("?")) {
				return baseUrl + requestEntity.url + "&" + paramString;
else {
				return baseUrl + requestEntity.url + "?" + paramString;
			}
		}
		return baseUrl + requestEntity.url;
	}
	private static List<NameValuePairtoList(Map<StringObjectparameters) {
		ArrayList<NameValuePairparamList = new ArrayList<NameValuePair>(parameters.size());
		for (Entry<StringObjectparam : parameters.entrySet()) {
			if (param.getValue() != null) {
				paramList.add(new BasicNameValuePair(param.getKey(), param.getValue().toString()));
			}
		}
		return paramList;
	}
	public static void configureBodyParams(HttpRequestEntity requestEntityHttpEntityEnclosingRequestBase request) {
		if (requestEntity.entity != null) {
			request.setEntity(requestEntity.entity);
else if (requestEntity.bodyText != null) {
			request.setEntity(new StringEntity(requestEntity.bodyText));
		}
	}
	public static boolean is400Error(ArangoException e) {
	}
	public static boolean is404Error(ArangoException e) {
	}
	public static boolean is412Error(ArangoException e) {
	}
	public static boolean is200(HttpResponseEntity res) {
		return res.getStatusCode() == .;
	}
	public static boolean is400Error(HttpResponseEntity res) {
	}
	public static boolean is404Error(HttpResponseEntity res) {
	}
	public static boolean is412Error(HttpResponseEntity res) {
	}
		return ;
	}
		return null;
	}
	public void setCurrentObject(InvocationObject currentObject) {
	}
	public void setPreDefinedResponse(HttpResponseEntity preDefinedResponse) {
		this. = preDefinedResponse;
	}
	public List<StringgetJobIds() {
		return ;
	}
		return ;
	}
	public void addJob(String jobIdInvocationObject invocationObject) {
		.add(jobId);
		.put(jobIdinvocationObject);
	}
	public String getLastJobId() {
		return .size() == 0 ? null : .get(.size() - 1);
	}
	public void resetJobs() {
		this. = new ArrayList<String>();
		this..clear();
	}
New to GrepCode? Check out our FAQ X