private HttpClient newHttpClient(String sslProtocol, HttpRequest request) {
HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, httpTimeoutsProvider.getConnectionTimeout());
HttpConnectionParams.setSoTimeout(params, httpTimeoutsProvider.getSocketTimeout());
// AG-1059: Need to follow redirects to ensure that if the host app is setup with Apache and
// mod_jk we can still
// fetch internal gadgets.
if (request.getFollowRedirects()) {
params.setBooleanParameter(ClientPNames.HANDLE_REDIRECTS, true);
params.setIntParameter(ClientPNames.MAX_REDIRECTS, 3);
}
params.setParameter(
ClientPNames.DEFAULT_HEADERS,
ImmutableSet.of(new BasicHeader("Accept-Encoding", "gzip, deflate")));
DefaultHttpClient client = new DefaultHttpClient(params);
// AG-1044: Need to use the JVM's default proxy configuration for requests.
ProxySelectorRoutePlanner routePlanner =
new ProxySelectorRoutePlanner(
client.getConnectionManager().getSchemeRegistry(), ProxySelector.getDefault());
client.setRoutePlanner(routePlanner);
client.addResponseInterceptor(new GzipDeflatingInterceptor());
client
.getConnectionManager()
.getSchemeRegistry()
.register(new Scheme("https", new CustomSSLSocketFactory(sslProtocol), 443));
return client;
}
public HttpResponse fetch(HttpRequest request) throws GadgetException {
if (returnNull) {
return null;
}
if (gadgetException != null) {
throw gadgetException;
}
if (runtimeException != null) {
throw runtimeException;
}
if (request.getFollowRedirects()) {
throw new RuntimeException("Not supposed to follow OAuth redirects");
}
String url = request.getUri().toString();
try {
if (url.startsWith(REQUEST_TOKEN_URL)) {
++requestTokenCount;
return handleRequestTokenUrl(request);
} else if (url.startsWith(ACCESS_TOKEN_URL)) {
++accessTokenCount;
return handleAccessTokenUrl(request);
} else if (url.startsWith(RESOURCE_URL)) {
++resourceAccessCount;
return handleResourceUrl(request);
} else if (url.startsWith(NOT_FOUND_URL)) {
return handleNotFoundUrl(request);
} else if (url.startsWith(ERROR_400)) {
return handleError400Url(request);
} else if (url.startsWith(ECHO_URL)) {
return handleEchoUrl(request);
}
} catch (Exception e) {
throw new RuntimeException("Problem with request for URL " + url, e);
}
throw new RuntimeException("Unexpected request for " + url);
}
public HttpResponse fetch(org.apache.shindig.gadgets.http.HttpRequest request)
throws GadgetException {
HttpUriRequest httpMethod = null;
Preconditions.checkNotNull(request);
final String methodType = request.getMethod();
final org.apache.http.HttpResponse response;
final long started = System.currentTimeMillis();
// Break the request Uri to its components:
Uri uri = request.getUri();
if (StringUtils.isEmpty(uri.getAuthority())) {
throw new GadgetException(
GadgetException.Code.INVALID_USER_DATA,
"Missing domain name for request: " + uri,
HttpServletResponse.SC_BAD_REQUEST);
}
if (StringUtils.isEmpty(uri.getScheme())) {
throw new GadgetException(
GadgetException.Code.INVALID_USER_DATA,
"Missing schema for request: " + uri,
HttpServletResponse.SC_BAD_REQUEST);
}
String[] hostparts = StringUtils.splitPreserveAllTokens(uri.getAuthority(), ':');
int port = -1; // default port
if (hostparts.length > 2) {
throw new GadgetException(
GadgetException.Code.INVALID_USER_DATA,
"Bad host name in request: " + uri.getAuthority(),
HttpServletResponse.SC_BAD_REQUEST);
}
if (hostparts.length == 2) {
try {
port = Integer.parseInt(hostparts[1]);
} catch (NumberFormatException e) {
throw new GadgetException(
GadgetException.Code.INVALID_USER_DATA,
"Bad port number in request: " + uri.getAuthority(),
HttpServletResponse.SC_BAD_REQUEST);
}
}
String requestUri = uri.getPath();
// Treat path as / if set as null.
if (uri.getPath() == null) {
requestUri = "/";
}
if (uri.getQuery() != null) {
requestUri += '?' + uri.getQuery();
}
// Get the http host to connect to.
HttpHost host = new HttpHost(hostparts[0], port, uri.getScheme());
try {
if ("POST".equals(methodType) || "PUT".equals(methodType)) {
HttpEntityEnclosingRequestBase enclosingMethod =
("POST".equals(methodType)) ? new HttpPost(requestUri) : new HttpPut(requestUri);
if (request.getPostBodyLength() > 0) {
enclosingMethod.setEntity(
new InputStreamEntity(request.getPostBody(), request.getPostBodyLength()));
}
httpMethod = enclosingMethod;
} else if ("GET".equals(methodType)) {
httpMethod = new HttpGet(requestUri);
} else if ("HEAD".equals(methodType)) {
httpMethod = new HttpHead(requestUri);
} else if ("DELETE".equals(methodType)) {
httpMethod = new HttpDelete(requestUri);
}
for (Map.Entry<String, List<String>> entry : request.getHeaders().entrySet()) {
httpMethod.addHeader(entry.getKey(), StringUtils.join(entry.getValue(), ','));
}
// Disable following redirects.
if (!request.getFollowRedirects()) {
httpMethod.getParams().setBooleanParameter(ClientPNames.HANDLE_REDIRECTS, false);
}
// HttpClient doesn't handle all cases when breaking url (specifically '_' in domain)
// So lets pass it the url parsed:
response = FETCHER.execute(host, httpMethod);
if (response == null) {
throw new IOException("Unknown problem with request");
}
long now = System.currentTimeMillis();
if (now - started > slowResponseWarning) {
slowResponseWarning(request, started, now);
}
return makeResponse(response);
} catch (Exception e) {
long now = System.currentTimeMillis();
// Find timeout exceptions, respond accordingly
if (TIMEOUT_EXCEPTIONS.contains(e.getClass())) {
LOG.info(
"Timeout for "
+ request.getUri()
+ " Exception: "
+ e.getClass().getName()
+ " - "
+ e.getMessage()
+ " - "
+ (now - started)
+ "ms");
return HttpResponse.timeout();
}
LOG.log(
Level.INFO,
"Got Exception fetching " + request.getUri() + " - " + (now - started) + "ms",
e);
// Separate shindig error from external error
throw new GadgetException(
GadgetException.Code.INTERNAL_SERVER_ERROR,
e,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} finally {
// cleanup any outstanding resources..
if (httpMethod != null)
try {
httpMethod.abort();
} catch (UnsupportedOperationException e) {
// ignore
}
}
}