public void init() throws Exception {
client = new HttpClient();
client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
client.setThreadPool(new ExecutorThreadPool(4, 256, timeout, TimeUnit.SECONDS));
client.setTimeout(timeout);
client.start();
}
/** Initialize the client object */
public StockManagerHTTPProxy(String serverAddress) throws Exception {
setServerAddress(serverAddress);
client = new HttpClient();
client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
client.setMaxConnectionsPerAddress(
BookStoreClientConstants.CLIENT_MAX_CONNECTION_ADDRESS); // max
// concurrent
// connections
// to
// every
// address
client.setThreadPool(
new QueuedThreadPool(BookStoreClientConstants.CLIENT_MAX_THREADSPOOL_THREADS)); // max
// threads
client.setTimeout(BookStoreClientConstants.CLIENT_MAX_TIMEOUT_MILLISECS); // seconds
// timeout;
// if
// no
// server
// reply,
// the
// request
// expires
client.start();
}
private static HttpClient httpClient() throws Exception {
if (_httpClient == null) {
_httpClient = new HttpClient();
_httpClient.setConnectorType(CONNECTOR_SELECT_CHANNEL);
_httpClient.setConnectTimeout(TIMEOUT_CONNECT);
_httpClient.start();
}
return _httpClient;
}
// TODO: client.start() could potentially have some side effects.
// Need to understand more of what's going on under the hood.
@Provides
HttpClient provideHttpClient() {
LOGGER.info("Providing http client for connection name " + connectionName);
HttpClient client = new HttpClient();
client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
client.setConnectTimeout(timeoutOption);
client.setTimeout(timeoutOption);
return client;
}
protected static void runTest(String requestUrl, long count) {
HttpClient client = new HttpClient();
client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
try {
client.start();
} catch (Exception ex) {
LOG.debug(ex);
}
if (client != null) {
for (long cnt = 0; cnt < count; cnt++) {
try {
ContentExchange getExchange = new ContentExchange();
getExchange.setURL(requestUrl);
getExchange.setMethod(HttpMethods.GET);
client.send(getExchange);
int state = getExchange.waitForDone();
String content = "";
int responseStatus = getExchange.getResponseStatus();
if (responseStatus == HttpStatus.OK_200) {
content = getExchange.getResponseContent();
}
Thread.sleep(100);
} catch (InterruptedException ex) {
break;
} catch (IOException ex) {
LOG.debug(ex);
}
}
try {
client.stop();
} catch (Exception ex) {
LOG.debug(ex);
}
}
}
protected void startClient(Realm realm) throws Exception {
_client = new HttpClient();
_client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);
if (realm != null) _client.setRealmResolver(new SimpleRealmResolver(realm));
_client.start();
}
@Test
public void testLastAccessTime() throws Exception {
String contextPath = "";
String servletMapping = "/server";
int maxInactivePeriod = 8;
int scavengePeriod = 2;
AbstractTestServer server1 = createServer(0, maxInactivePeriod, scavengePeriod);
server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
server1.start();
int port1 = server1.getPort();
try {
AbstractTestServer server2 = createServer(0, maxInactivePeriod, scavengePeriod);
server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
server2.start();
int port2 = server2.getPort();
try {
HttpClient client = new HttpClient();
client.setConnectorType(HttpClient.CONNECTOR_SOCKET);
client.start();
try {
// Perform one request to server1 to create a session
ContentExchange exchange1 = new ContentExchange(true);
exchange1.setMethod(HttpMethods.GET);
exchange1.setURL(
"http://localhost:" + port1 + contextPath + servletMapping + "?action=init");
client.send(exchange1);
exchange1.waitForDone();
assertEquals(HttpServletResponse.SC_OK, exchange1.getResponseStatus());
assertEquals("test", exchange1.getResponseContent());
String sessionCookie = exchange1.getResponseFields().getStringField("Set-Cookie");
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// Perform some request to server2 using the session cookie from the previous request
// This should migrate the session from server1 to server2, and leave server1's
// session in a very stale state, while server2 has a very fresh session.
// We want to test that optimizations done to the saving of the shared lastAccessTime
// do not break the correct working
int requestInterval = 500;
for (int i = 0; i < maxInactivePeriod * (1000 / requestInterval); ++i) {
ContentExchange exchange2 = new ContentExchange(true);
exchange2.setMethod(HttpMethods.GET);
exchange2.setURL("http://localhost:" + port2 + contextPath + servletMapping);
exchange2.getRequestFields().add("Cookie", sessionCookie);
client.send(exchange2);
exchange2.waitForDone();
assertEquals(HttpServletResponse.SC_OK, exchange2.getResponseStatus());
assertEquals("test", exchange2.getResponseContent());
String setCookie = exchange1.getResponseFields().getStringField("Set-Cookie");
if (setCookie != null)
sessionCookie = setCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
Thread.sleep(requestInterval);
}
// At this point, session1 should be eligible for expiration.
// Let's wait for the scavenger to run, waiting 2.5 times the scavenger period
Thread.sleep(scavengePeriod * 2500L);
// Access again server1, and ensure that we can still access the session
exchange1 = new ContentExchange(true);
exchange1.setMethod(HttpMethods.GET);
exchange1.setURL("http://localhost:" + port1 + contextPath + servletMapping);
exchange1.getRequestFields().add("Cookie", sessionCookie);
client.send(exchange1);
exchange1.waitForDone();
assertEquals(HttpServletResponse.SC_OK, exchange1.getResponseStatus());
// test that the session was kept alive by server 2 and still contains what server1 put in
// it
assertEquals("test", exchange1.getResponseContent());
} finally {
client.stop();
}
} finally {
server2.stop();
}
} finally {
server1.stop();
}
}