We Keep Coding

how to provide custom uri and port to send SMS to phone number using twilio sdk library in java?

I have to send SMS on phone number from Java function.
I am using below sample code from Twilio site for POC and it's working fine without any issue.
public static final String ACCOUNT_SID = "ACXXXXXXXXXXXXXXXXXXX";
public static final String AUTH_TOKEN = "XXXXXXXXXXX";
public static void main(String[] args) {
Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
Message message = Message.creator(new PhoneNumber("+1111111111"),
new PhoneNumber("XXXXX"),
"This is the ship that made the Kessel Run in fourteen parsecs?").create();
System.out.println(message.getSid());
}
Now I have to pass custom uri which is DP URI with custom port, which is working fine, when i am testing with postman.
but how can i fit here custom URI in this java code?
or do i have to use different code?
or do i have to create my own rest client to work with custom uri?
NOTE: I am using implementation 'com.twilio.sdk:twilio:8.18.0' in build.gradle file. i checked all available options of creator constructor. None of options takes from Number, To Number, Body and URI.

Twilio developer evangelist here.
To access the API using the Twilio Java SDK through a proxy requires you to provide an HTTP Client that uses the proxy. This is documented here in custom documents for the Twilio Java library.
The full code from that article is:
import com.twilio.http.HttpClient;
import com.twilio.http.NetworkHttpClient;
import com.twilio.http.TwilioRestClient;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
public class ProxiedTwilioClientCreator {
private String username;
private String password;
private String proxyHost;
private int proxyPort;
private HttpClient httpClient;
/**
* Constructor for ProxiedTwilioClientCreator
* #param username
* #param password
* #param proxyHost
* #param proxyPort
*/
public ProxiedTwilioClientCreator(String username, String password, String proxyHost, int proxyPort) {
this.username = username;
this.password = password;
this.proxyHost = proxyHost;
this.proxyPort = proxyPort;
}
/**
* Creates a custom HttpClient based on default config as seen on:
* {#link com.twilio.http.NetworkHttpClient#NetworkHttpClient() constructor}
*/
private void createHttpClient() {
RequestConfig config = RequestConfig.custom()
.setConnectTimeout(10000)
.setSocketTimeout(30500)
.build();
PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
connectionManager.setDefaultMaxPerRoute(10);
connectionManager.setMaxTotal(10*2);
HttpHost proxy = new HttpHost(proxyHost, proxyPort);
HttpClientBuilder clientBuilder = HttpClientBuilder.create();
clientBuilder
.setConnectionManager(connectionManager)
.setProxy(proxy)
.setDefaultRequestConfig(config);
// Inclusion of Twilio headers and build() is executed under this constructor
this.httpClient = new NetworkHttpClient(clientBuilder);
}
/**
* Get the custom client or builds a new one
* #return a TwilioRestClient object
*/
public TwilioRestClient getClient() {
if (this.httpClient == null) {
this.createHttpClient();
}
TwilioRestClient.Builder builder = new TwilioRestClient.Builder(username, password);
return builder.httpClient(this.httpClient).build();
}
}
Which you can then use like this to, for example, send an SMS message:
// Install the Java helper library from twilio.com/docs/java/install
import com.twilio.Twilio;
import com.twilio.http.TwilioRestClient;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;
import io.github.cdimascio.dotenv.Dotenv;
public class Example {
public static void main(String args[]) {
Dotenv dotenv = Dotenv.configure()
.directory(".")
.load();
String ACCOUNT_SID = dotenv.get("ACCOUNT_SID");
String AUTH_TOKEN = dotenv.get("AUTH_TOKEN");
String PROXY_HOST = dotenv.get("PROXY_HOST");
int PROXY_PORT = Integer.parseInt(dotenv.get("PROXY_PORT"));
Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
ProxiedTwilioClientCreator clientCreator = new ProxiedTwilioClientCreator(
ACCOUNT_SID, AUTH_TOKEN, PROXY_HOST, PROXY_PORT);
TwilioRestClient twilioRestClient = clientCreator.getClient();
Twilio.setRestClient(twilioRestClient);
Message message = Message.creator(new PhoneNumber("+15558675310"),
new PhoneNumber("+15017122661"), "Hey there!").create();
System.out.println(message.getSid());
}
}

How to make a RPC-JSON java server

I have a client RPC-JSON in Android and I am trying make a RPC-JSON Server with a library for Java (http://software.dzhuvinov.com/json-rpc-2.0-server.html). This is the official example:
// The JSON-RPC 2.0 Base classes that define the
// JSON-RPC 2.0 protocol messages
import com.thetransactioncompany.jsonrpc2.*;
// The JSON-RPC 2.0 server framework package
import com.thetransactioncompany.jsonrpc2.server.*;
import java.text.*;
import java.util.*;
/**
* Demonstration of the JSON-RPC 2.0 Server framework usage. The request
* handlers are implemented as static nested classes for convenience, but in
* real life applications may be defined as regular classes within their old
* source files.
*
* #author Vladimir Dzhuvinov
* #version 2011-03-05
*/
public class Example {
// Implements a handler for an "echo" JSON-RPC method
public static class EchoHandler implements RequestHandler {
// Reports the method names of the handled requests
public String[] handledRequests() {
return new String[]{"echo"};
}
// Processes the requests
public JSONRPC2Response process(JSONRPC2Request req, MessageContext ctx) {
if (req.getMethod().equals("echo")) {
// Echo first parameter
List params = (List)req.getParams();
Object input = params.get(0);
return new JSONRPC2Response(input, req.getID());
}
else {
// Method name not supported
return new JSONRPC2Response(JSONRPC2Error.METHOD_NOT_FOUND, req.getID());
}
}
}
// Implements a handler for "getDate" and "getTime" JSON-RPC methods
// that return the current date and time
public static class DateTimeHandler implements RequestHandler {
// Reports the method names of the handled requests
public String[] handledRequests() {
return new String[]{"getDate", "getTime"};
}
// Processes the requests
public JSONRPC2Response process(JSONRPC2Request req, MessageContext ctx) {
if (req.getMethod().equals("getDate")) {
DateFormat df = DateFormat.getDateInstance();
String date = df.format(new Date());
return new JSONRPC2Response(date, req.getID());
}
else if (req.getMethod().equals("getTime")) {
DateFormat df = DateFormat.getTimeInstance();
String time = df.format(new Date());
return new JSONRPC2Response(time, req.getID());
}
else {
// Method name not supported
return new JSONRPC2Response(JSONRPC2Error.METHOD_NOT_FOUND, req.getID());
}
}
}
public static void main(String[] args) {
// Create a new JSON-RPC 2.0 request dispatcher
Dispatcher dispatcher = new Dispatcher();
// Register the "echo", "getDate" and "getTime" handlers with it
dispatcher.register(new EchoHandler());
dispatcher.register(new DateTimeHandler());
// Simulate an "echo" JSON-RPC 2.0 request
List echoParam = new LinkedList();
echoParam.add("Hello world!");
JSONRPC2Request req = new JSONRPC2Request("echo", echoParam, "req-id-01");
System.out.println("Request: \n" + req);
JSONRPC2Response resp = dispatcher.process(req, null);
System.out.println("Response: \n" + resp);
// Simulate a "getDate" JSON-RPC 2.0 request
req = new JSONRPC2Request("getDate", "req-id-02");
System.out.println("Request: \n" + req);
resp = dispatcher.process(req, null);
System.out.println("Response: \n" + resp);
// Simulate a "getTime" JSON-RPC 2.0 request
req = new JSONRPC2Request("getTime", "req-id-03");
System.out.println("Request: \n" + req);
resp = dispatcher.process(req, null);
System.out.println("Response: \n" + resp);
}
}
I search in the manual and Google but I don't understand how I can do that the server is waiting for a request and send a response. How I can do it?

Spring security with google Oauth

I have been working on a web application in which I have used Google oauth and Spring MVC. I have implemented the google oauth in which the user is directed to the desired URL if the user is authenticated by the google oauth. For achieving this functionality i have used the google GogleAuthHelper class. Here is my code
package com.mob.googleoauth;
import java.io.IOException;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.servlet.http.HttpSession;
import org.json.JSONException;
import org.json.JSONObject;
import com.google.api.client.auth.oauth2.AuthorizationCodeRequestUrl;
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.auth.oauth2.TokenResponseException;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeRequestUrl;
import com.google.api.client.googleapis.auth.oauth2.GoogleTokenResponse;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestFactory;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson.JacksonFactory;
public final class GoogleAuthHelper {
private static final String CLIENT_ID = "";
private static final String CLIENT_SECRET = " ";
/**
* Callback URI that google will redirect to after successful authentication
*/
private static final String CALLBACK_URI = "http://localhost:8080/orgchart/oauthRedirect";
// private static final String HD = " ";
// start google authentication constants
private static final Iterable<String> SCOPE = Arrays
.asList("https://www.googleapis.com/auth/userinfo.profile;https://www.googleapis.com/auth/userinfo.email"
.split(";"));
private static final String USER_INFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo";
private static final JsonFactory JSON_FACTORY = new JacksonFactory();
private static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
// end google authentication constants
private String stateToken;
private final GoogleAuthorizationCodeFlow flow;
/**
* Constructor initializes the Google Authorization Code Flow with CLIENT
* ID, SECRET, and SCOPE
*/
public GoogleAuthHelper() {
System.out.println("google auth helper called");
flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT,
JSON_FACTORY, CLIENT_ID, CLIENT_SECRET, SCOPE).build();
flow.newAuthorizationUrl().setApprovalPrompt("force").setAccessType("offline");
// AuthorizationCodeRequestUrl authorizationUrl = flow
// .newAuthorizationUrl().setRedirectUri(CALLBACK_URI)
// .setApprovalPrompt("force").setAccessType("offline");
generateStateToken();
}
/**
* Builds a login URL based on client ID, secret, callback URI, and scope
*/
public String buildLoginUrl() {
System.out.println("building uri called");
final GoogleAuthorizationCodeRequestUrl url = flow
.newAuthorizationUrl();
return url.setRedirectUri(CALLBACK_URI).setState(stateToken).build();
}
/**
* Generates a secure state token
*/
private void generateStateToken() {
System.out.println("generated token called");
SecureRandom sr1 = new SecureRandom();
// System.out.println(sr1);
stateToken = "google;" + sr1.nextInt();
}
/**
* Accessor for state token
*/
public String getStateToken() {
System.out.println("gettoken called");
return stateToken;
}
/**
* Expects an Authentication Code, and makes an authenticated request for
* the user's profile information
*
* #return JSON formatted user profile information
* #param authCode
* authentication code provided by google
* #throws JSONException
*/
#SuppressWarnings("unchecked")
public List getUserInfoJson(final String authCode,HttpSession session) throws IOException,
JSONException {
List ls = new ArrayList();
try{
System.out.println("getuserinfojson called");
final GoogleTokenResponse response = flow.newTokenRequest(authCode)
.setRedirectUri(CALLBACK_URI).execute();
session.setAttribute("userToken", response.getAccessToken());
final Credential credential = flow.createAndStoreCredential(response,
null);
final HttpRequestFactory requestFactory = HTTP_TRANSPORT
.createRequestFactory(credential);
// Make an authenticated request
final GenericUrl url = new GenericUrl(USER_INFO_URL);
final HttpRequest request = requestFactory.buildGetRequest(url);
request.getHeaders().setContentType("application/json");
final String jsonIdentity = request.execute().parseAsString();
// System.out.println(jsonIdentity);
JSONObject object = new JSONObject(jsonIdentity);
String email = object.getString("email");
String name = object.getString("name");
String picture = object.getString("picture");
ls.add(email);
ls.add(name);
ls.add(picture);
}
catch(NullPointerException e)
{
throw e;
}
catch (TokenResponseException e) {
throw e;
}
return ls;
}
}
ABove works fine for one time that is authenticating the user and redirecting to the given URL but after that the application is not secure. That is URL in my application are not secure. For this I want to include the spring security along with google oauth. Is there any good detailed example to do that. I have searched the google and have not been successful. I want a good working example for spring security and google oauth.
thanks for nay help

Here I am giving you few links. It was helpful for me for understanding purpose. Hope it would help you too.
On this link you can go for your desired category. Considering Spring Security for OAuth, this you can check.
http://docs.spring.io/spring-security/oauth/
http://www.hsc.com/Portals/0/Uploads/Articles/WP_Securing_RESTful_WebServices_OAuth2635406646412464000.pdf
http://porterhead.blogspot.in/2014/05/securing-rest-services-with-spring.html

Jersey Client: adding Cookies does not change Builder

My first implementation using the Jersey client code with cookies does not successfully maintain session to next call. What is suspicious to me is that the method
Builder javax.ws.rs.client.Invocation.Builder.cookie(String s, String s1)
does not return a different instance of the builder. Shouldn't it? Either way, my login request is denied with message "Your session expired due to inactivity.", which seems to imply to me that the request isn't arriving with the same session id as previous.
See anything wrong with this code? The culprit in question is method #applyCookies(Builder) which does not return anything different after the cookies have been set.
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import javax.ws.rs.HttpMethod;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.Invocation.Builder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Cookie;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.NewCookie;
import javax.ws.rs.core.Response;
import org.apache.log4j.Logger;
import org.glassfish.jersey.client.filter.HttpBasicAuthFilter;
/**
* A JAX-RS <a href="https://jax-rs-spec.java.net/" /> connector that uses
* Jersey <a href="https://jersey.java.net"/> as the API to create a client that
* will connect to a remote REST service.
*/
public class JerseyConnector extends WebServiceConnector
{
/** Debug logger. */
protected static final Logger logger = Logger.getLogger(JerseyConnector.class);
/**
* Simple test execution method.
*
* #param args
* #throws MessageException
*/
public static void main(String[] args) throws MessageException
{
JerseyConnector conn = new JerseyConnector();
conn.setProviderURL("http://somehost.somewhere.com:7203/rest");
conn.open();
String sessConf = (String)conn.send("initiateSession");
HashMap<String,String> content = new HashMap<String,String>(3);
content.put("sessionConfirmation", sessConf);
content.put("password", "password");
content.put("login", "joe");
String body = JSONMapFormatter.toJSON(content);
String loginResponse = (String)conn.send(new RESTRequest("login", body, HttpMethod.POST));
System.out.println(loginResponse);
}
protected WebTarget webTarget;
protected Map<String,Cookie> cookies;
/**
* Calls the {#link #webTarget} and provides the {#link String} response.
* The request method defaults to {#link HttpMethod#GET}.
* <p>
* If the <code>message</code> is a {#link String}, it is assumed to be the
* suffix URI to append to the provider URL of the {#link #webTarget},
* unless the string begins with a "{", in which case it is assumed to be
* the JSON request body to send.
* <p>
* If the <code>message</code> is a {#link RESTRequest}, the path, body and
* HTTP method will be determined from that.
* <p>
* Otherwise, the <code>toString()</code> version of the message will be
* sent as the body of the message.
*
* #see WebTarget#path(String)
* #see WebTarget#request()
* #see #getProviderURL()
* #see oracle.retail.stores.commext.connector.webservice.WebServiceConnector#send(java.io.Serializable)
*/
#Override
protected Serializable send(Serializable message) throws MessageException
{
RESTRequest request = null;
// determine path and body content if any
if (message instanceof RESTRequest)
{
request = (RESTRequest)message;
}
else
{
request = new RESTRequest();
String messageString = message.toString();
if (messageString.startsWith("{"))
{
request.body = (String)message;
}
else
{
request.path = (String)message;
}
}
// send request, get response
Response response = sendRequest(webTarget, request);
logger.debug("Response received.");
// remember cookies that came in the response
rememberCookies(response);
// return response as a string
return response.readEntity(String.class);
}
/* (non-Javadoc)
* #see oracle.retail.stores.commext.connector.webservice.WebServiceConnector#openConnector()
*/
#Override
protected void openConnector() throws MessageException
{
super.openConnector();
// create a client
logger.debug("Creating new client.");
Client client = ClientBuilder.newClient();
// register the auth creds
if (!Util.isEmpty(getUserName()))
{
logger.debug("Registering user credentials with client.");
client.register(new HttpBasicAuthFilter(getUserName(), getPassword()));
}
else
{
logger.info("No credentials specified for \"" + getName() + "\".");
}
// open the target url
if (logger.isDebugEnabled())
{
logger.debug("Creating webTarget with \"" + getProviderURL() + "\".");
}
webTarget = client.target(getProviderURL());
// construct a new cookie map
cookies = new HashMap<String,Cookie>(3);
}
/**
* Returns the response after invoking the specified request on the specified
* target.
*
* #param target
* #param request
* #return
*/
protected Response sendRequest(WebTarget target, RESTRequest request)
{
// retarget destination
if (request.path != null)
{
target = target.path(request.path);
}
if (logger.isDebugEnabled())
{
logger.debug("Making service request " + request);
}
// build request
Builder builder = target.request(MediaType.APPLICATION_JSON_TYPE);
// apply cookies
builder = applyCookies(builder);
// call webservice and return response as a string
if (HttpMethod.POST.equals(request.httpMethod))
{
return builder.post(Entity.entity(request.body, MediaType.APPLICATION_JSON));
}
else if (HttpMethod.PUT.equals(request.httpMethod))
{
return builder.put(Entity.entity(request.body, MediaType.APPLICATION_JSON));
}
else if (HttpMethod.DELETE.equals(request.httpMethod))
{
return target.request(request.body).delete();
}
// default to HttpMethod.GET
return target.request(request.body).get();
}
/**
* Apply all the cookies in the cookies map onto the request builder.
*
* #param builder
* #return the cookied builder
*/
private Builder applyCookies(Builder builder)
{
if (logger.isDebugEnabled())
{
logger.debug("Applying " + cookies.size() + " cookies: " + cookies);
}
for (Cookie cookie : cookies.values())
{
builder = builder.cookie(cookie.getName(), cookie.getValue());
}
return builder;
}
/**
* Put all the cookies from the response into the map of cookies being
* remembered.
*
* #param response
*/
private void rememberCookies(Response response)
{
Map<String,NewCookie> newCookies = response.getCookies();
if (logger.isDebugEnabled())
{
logger.debug("Remembering " + newCookies.size() + " cookies: " + newCookies);
}
cookies.putAll(newCookies);
}
// -------------------------------------------------------------------------
/**
* Request parameters that can be sent to this connector in order to specify
* the path (URL sub-sequence) and body (contents) of the request message to
* send.
*/
public static class RESTRequest implements Serializable
{
private static final long serialVersionUID = 5675990073393175886L;
private String path;
private String body;
private String httpMethod;
/**
* Internal constructor
*/
private RESTRequest()
{
}
/**
* #param path
* #param body
*/
public RESTRequest(String path, String body)
{
this.path = path;
this.body = body;
}
/**
* #param path
* #param body
* #param httpMethod see values at {#link javax.ws.rs.HttpMethod}
*/
public RESTRequest(String path, String body, String httpMethod)
{
this.path = path;
this.body = body;
this.httpMethod = httpMethod;
}
/**
* #return the path
*/
public String getPath()
{
return path;
}
/**
* #return the body
*/
public String getBody()
{
return body;
}
/**
* #return the httpMethod
* #see javax.ws.rs.HttpMethod
*/
public String getHttpMethod()
{
return httpMethod;
}
/* (non-Javadoc)
* #see java.lang.Object#toString()
*/
#Override
public String toString()
{
return "RESTRequest[" + httpMethod + ", " + path + ", with body=" + body + "]";
}
}
}

The defect was in the bottom of the #sendRequest() method. It was ignoring the Builder object returned and re-using the WebTarget to create a new request (which creates a new builder. The last three lines of code in that method should have been:
return builder.buildDelete().invoke();
}
// default to HttpMethod.GET
return builder.buildGet().invoke();

Servlet Filter is Returning "Proxy Error" on AWS

I have set up a Filter to add crawler support for my GWT web application. The idea is to catch all requests that contain "_escaped_fragment_=" and supply a snapshot for the crawler.
I have set up the Filter using Guice as follows:
filter("/*").through(CrawlerFilter.class);
The following is the code for the CrawlerFilter class (many thanks to Patrick):
#Singleton
public class CrawlerFilter implements Filter {
private static final Logger logger = Logger.getLogger(CrawlerFilter.class.getName());
/**
* Special URL token that gets passed from the crawler to the servlet
* filter. This token is used in case there are already existing query
* parameters.
*/
private static final String ESCAPED_FRAGMENT_FORMAT1 = "_escaped_fragment_=";
private static final int ESCAPED_FRAGMENT_LENGTH1 = ESCAPED_FRAGMENT_FORMAT1.length();
/**
* Special URL token that gets passed from the crawler to the servlet
* filter. This token is used in case there are not already existing query
* parameters.
*/
private static final String ESCAPED_FRAGMENT_FORMAT2 = "&" + ESCAPED_FRAGMENT_FORMAT1;
private static final int ESCAPED_FRAGMENT_LENGTH2 = ESCAPED_FRAGMENT_FORMAT2.length();
private class SyncAllAjaxController extends NicelyResynchronizingAjaxController {
private static final long serialVersionUID = 1L;
#Override
public boolean processSynchron(HtmlPage page, WebRequest request, boolean async) {
return true;
}
}
private WebClient webClient = null;
private static final long _pumpEventLoopTimeoutMillis = 30000;
private static final long _jsTimeoutMillis = 1000;
private static final long _pageWaitMillis = 200;
final int _maxLoopChecks = 2;
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException,
ServletException {
// Grab the request uri and query strings.
final HttpServletRequest httpRequest = (HttpServletRequest) request;
final String requestURI = httpRequest.getRequestURI();
final String queryString = httpRequest.getQueryString();
final HttpServletResponse httpResponse = (HttpServletResponse) response;
if ((queryString != null) && (queryString.contains(ESCAPED_FRAGMENT_FORMAT1))) {
// This is a Googlebot crawler request, let's return a static
// indexable html page post javascript execution, as rendered in the browser.
final String domain = httpRequest.getServerName();
final int port = httpRequest.getServerPort();
// Rewrite the URL back to the original #! version
// -- basically remove _escaped_fragment_ from the query.
// Unescape any %XX characters as need be.
final String urlStringWithHashFragment = requestURI + rewriteQueryString(queryString);
final String scheme = httpRequest.getScheme();
final URL urlWithHashFragment = new URL(scheme, "127.0.0.1", port, urlStringWithHashFragment); // get from localhost
final WebRequest webRequest = new WebRequest(urlWithHashFragment);
// Use the headless browser to obtain an HTML snapshot.
webClient = new WebClient(BrowserVersion.FIREFOX_3_6);
webClient.getCache().clear();
webClient.setJavaScriptEnabled(true);
webClient.setThrowExceptionOnScriptError(false);
webClient.setRedirectEnabled(false);
webClient.setAjaxController(new SyncAllAjaxController());
webClient.setCssErrorHandler(new SilentCssErrorHandler());
if (logger.getLevel() == Level.FINEST)
logger.log(Level.FINEST, "HtmlUnit starting webClient.getPage(webRequest) where webRequest = "
+ webRequest.toString());
final HtmlPage page = webClient.getPage(webRequest);
// Important! Give the headless browser enough time to execute
// JavaScript
// The exact time to wait may depend on your application.
webClient.getJavaScriptEngine().pumpEventLoop(_pumpEventLoopTimeoutMillis);
int waitForBackgroundJavaScript = webClient.waitForBackgroundJavaScript(_jsTimeoutMillis);
int loopCount = 0;
while (waitForBackgroundJavaScript > 0 && loopCount < _maxLoopChecks) {
++loopCount;
waitForBackgroundJavaScript = webClient.waitForBackgroundJavaScript(_jsTimeoutMillis);
if (waitForBackgroundJavaScript == 0) {
if (logger.getLevel() == Level.FINEST)
logger.log(Level.FINEST, "HtmlUnit exits background javascript at loop counter " + loopCount);
break;
}
synchronized (page) {
if (logger.getLevel() == Level.FINEST)
logger.log(Level.FINEST, "HtmlUnit waits for background javascript at loop counter "
+ loopCount);
try {
page.wait(_pageWaitMillis);
}
catch (InterruptedException e) {
logger.log(Level.SEVERE, "HtmlUnit ERROR on page.wait at loop counter " + loopCount);
e.printStackTrace();
}
}
}
webClient.getAjaxController().processSynchron(page, webRequest, false);
if (webClient.getJavaScriptEngine().isScriptRunning()) {
logger.log(Level.WARNING, "HtmlUnit webClient.getJavaScriptEngine().shutdownJavaScriptExecutor()");
webClient.getJavaScriptEngine().shutdownJavaScriptExecutor();
}
// Return the static snapshot.
final String staticSnapshotHtml = page.asXml();
httpResponse.setContentType("text/html;charset=UTF-8");
final PrintWriter out = httpResponse.getWriter();
out.println("<hr />");
out.println("<center><h3>This is a non-interactive snapshot for crawlers. Follow <a href=\"");
out.println(urlWithHashFragment + "\">this link</a> for the interactive application.<br></h3></center>");
out.println("<hr />");
out.println(staticSnapshotHtml);
// Close web client.
webClient.closeAllWindows();
out.println("");
out.flush();
out.close();
if (logger.getLevel() == Level.FINEST)
logger.log(Level.FINEST, "HtmlUnit completed webClient.getPage(webRequest) where webRequest = "
+ webRequest.toString());
}
else {
if (requestURI.contains(".nocache.")) {
// Ensure the gwt nocache bootstrapping file is never cached.
// References:
// https://stackoverflow.com/questions/4274053/how-to-clear-cache-in-gwt
// http://seewah.blogspot.com/2009/02/gwt-tips-2-nocachejs-getting-cached-in.html
//
final Date now = new Date();
httpResponse.setDateHeader("Date", now.getTime());
httpResponse.setDateHeader("Expires", now.getTime() - 86400000L); // One day old.
httpResponse.setHeader("Pragma", "no-cache");
httpResponse.setHeader("Cache-control", "no-cache, no-store, must-revalidate");
}
filterChain.doFilter(request, response);
}
}
/**
* Maps from the query string that contains _escaped_fragment_ to one that
* doesn't, but is instead followed by a hash fragment. It also unescapes
* any characters that were escaped by the crawler. If the query string does
* not contain _escaped_fragment_, it is not modified.
*
* #param queryString
* #return A modified query string followed by a hash fragment if
* applicable. The non-modified query string otherwise.
* #throws UnsupportedEncodingException
*/
private static String rewriteQueryString(String queryString) throws UnsupportedEncodingException {
// Seek the escaped fragment.
int index = queryString.indexOf(ESCAPED_FRAGMENT_FORMAT2);
int length = ESCAPED_FRAGMENT_LENGTH2;
if (index == -1) {
index = queryString.indexOf(ESCAPED_FRAGMENT_FORMAT1);
length = ESCAPED_FRAGMENT_LENGTH1;
}
if (index != -1) {
// Found the escaped fragment, so build back the original decoded
// one.
final StringBuilder queryStringSb = new StringBuilder();
// Add url parameters if any.
if (index > 0) {
queryStringSb.append("?");
queryStringSb.append(queryString.substring(0, index));
}
// Add the hash fragment as a replacement for the escaped fragment.
queryStringSb.append("#!");
// Add the decoded token.
final String token2Decode = queryString.substring(index + length, queryString.length());
final String tokenDecoded = URLDecoder.decode(token2Decode, "UTF-8");
queryStringSb.append(tokenDecoded);
return queryStringSb.toString();
}
return queryString;
}
#Override
public void destroy() {
if (webClient != null)
webClient.closeAllWindows();
}
#Override
public void init(FilterConfig config) throws ServletException {
}
}
It uses HtmlUnit to create the snapshot.
However; the error occurs when I try to access the snapshot using a regular browser. The URL that I enter is of the form:
http://www.myapp.com/?_escaped_fragment_=myobject%3Bid%3D507ac730e4b0e2b7a73b1b81
But the processing by the Filter results in the following error:
Proxy Error
The proxy server received an invalid response from an upstream server.
The proxy server could not handle the request GET /.
Reason: Error reading from remote server
Apache/2.2.22 (Amazon) Server at www.myapp.com Port 80
Any help would be appreciated.