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();
}
/**
* Create a http client
*
* @return
* @throws Exception
*/
private static BayeuxClient makeClient() throws Exception {
HttpClient httpClient = new HttpClient();
httpClient.setConnectTimeout(connectionTimeout);
httpClient.setTimeout(readTimeout); // TODO optional parameters
httpClient.start();
SoapLoginUtil.login(httpClient, userName, password);
final String sessionId = SoapLoginUtil.getSessionId();
String endpoint = SoapLoginUtil.getEndpoint();
System.out.println("Login successful!\nEndpoint: " + endpoint + "\nSessionid=" + sessionId);
Map<String, Object> options = new HashMap<String, Object>();
options.put(ClientTransport.TIMEOUT_OPTION, readTimeout);
LongPollingTransport transport =
new LongPollingTransport(options, httpClient) {
@Override
protected void customize(ContentExchange exchange) {
super.customize(exchange);
exchange.addRequestHeader("Authorization", "OAuth " + sessionId);
}
};
BayeuxClient client = new BayeuxClient(salesforceStreamingEndpoint(endpoint), transport);
if (useCookies) establishCookies(client, userName, sessionId);
return client;
}
@BeforeClass
public static void startServer() throws Exception {
server = new Server();
ServerConnector connector = new ServerConnector(server);
connector.setIdleTimeout(30000);
server.addConnector(connector);
ServletContextHandler context = new ServletContextHandler(server, "/");
// CometD servlet
ServletHolder cometdServletHolder = new ServletHolder(CometDServlet.class);
cometdServletHolder.setInitParameter("timeout", "10000");
cometdServletHolder.setInitParameter("multiSessionInterval", "2000");
cometdServletHolder.setInitOrder(1);
String cometdServletPath = "/cometd";
context.addServlet(cometdServletHolder, cometdServletPath + "/*");
server.start();
int port = connector.getLocalPort();
cometdURL = "http://localhost:" + port + cometdServletPath;
httpClient = new HttpClient();
httpClient.start();
}
protected void startClient() throws Exception {
if (httpClient != null) {
stopClient();
}
httpClient = new HttpClient();
httpClient.start();
}
@Test
public void testSessionMigration() throws Exception {
String contextPath = "";
String servletMapping = "/server";
AbstractTestServer server1 = createServer(0);
server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
try {
server1.start();
int port1 = server1.getPort();
AbstractTestServer server2 = createServer(0);
server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
try {
server2.start();
int port2 = server2.getPort();
HttpClient client = new HttpClient();
client.start();
try {
// Perform one request to server1 to create a session
int value = 1;
Request request1 =
client.POST(
"http://localhost:"
+ port1
+ contextPath
+ servletMapping
+ "?action=set&value="
+ value);
ContentResponse response1 = request1.send();
assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
String sessionCookie = response1.getHeaders().get("Set-Cookie");
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// Perform a request to server2 using the session cookie from the previous request
// This should migrate the session from server1 to server2.
Request request2 =
client.newRequest(
"http://localhost:" + port2 + contextPath + servletMapping + "?action=get");
request2.header("Cookie", sessionCookie);
ContentResponse response2 = request2.send();
assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
String response = response2.getContentAsString();
assertEquals(response.trim(), String.valueOf(value));
} finally {
client.stop();
}
} finally {
server2.stop();
}
} finally {
server1.stop();
}
}
@Test
public void testAttributeNamesWithDots() throws Exception {
String contextPath = "";
String servletMapping = "/server";
int maxInactivePeriod = 10000;
int scavengePeriod = 20000;
AbstractTestServer server1 = createServer(0, maxInactivePeriod, scavengePeriod);
server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
server1.start();
int port1 = server1.getPort();
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.start();
try {
// Perform one request to server1 to create a session with attribute with dotted name
ContentResponse response =
client.GET("http://localhost:" + port1 + contextPath + servletMapping + "?action=init");
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
String resp = response.getContentAsString();
String[] sessionTestResponse = resp.split("/");
assertEquals("a.b.c", sessionTestResponse[0]);
String sessionCookie = response.getHeaders().get(HttpHeader.SET_COOKIE);
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// Make a request to the 2nd server which will do a refresh, use TestServlet to ensure that
// the
// session attribute with dotted name is not removed
Request request2 =
client.newRequest(
"http://localhost:" + port2 + contextPath + servletMapping + "?action=get");
request2.header("Cookie", sessionCookie);
ContentResponse response2 = request2.send();
assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
} finally {
client.stop();
}
} finally {
server1.stop();
server2.stop();
}
}
@Before
public void setUp() throws Exception {
handler.setName("handler");
handler.setHandler(new DefaultHandler());
server.addConnector(connector);
server.setHandler(handler);
server.start();
client.start();
}
private HttpClient prepareClient() throws Exception {
HttpClient result = new HttpClient();
result
.getProxyConfiguration()
.getProxies()
.add(new HttpProxy("localhost", proxyConnector.getLocalPort()));
result.start();
return result;
}
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;
}
/**
* If nodeA creates a session, and just afterwards crashes, it is the only node that knows about
* the session. We want to test that the session data is gone after scavenging.
*/
@Test
public void testOrphanedSession() throws Exception {
// Disable scavenging for the first server, so that we simulate its "crash".
String contextPath = "";
String servletMapping = "/server";
int inactivePeriod = 5;
AbstractTestServer server1 = createServer(0, inactivePeriod, -1);
server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
try {
server1.start();
int port1 = server1.getPort();
int scavengePeriod = 2;
AbstractTestServer server2 = createServer(0, inactivePeriod, scavengePeriod);
server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
try {
server2.start();
int port2 = server2.getPort();
HttpClient client = new HttpClient();
client.start();
try {
// Connect to server1 to create a session and get its session cookie
ContentResponse response1 =
client.GET(
"http://localhost:" + port1 + contextPath + servletMapping + "?action=init");
assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
String sessionCookie = response1.getHeaders().getStringField("Set-Cookie");
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// Wait for the session to expire.
// The first node does not do any scavenging, but the session
// must be removed by scavenging done in the other node.
Thread.sleep(TimeUnit.SECONDS.toMillis(inactivePeriod + 2L * scavengePeriod));
// Perform one request to server2 to be sure that the session has been expired
Request request =
client.newRequest(
"http://localhost:" + port2 + contextPath + servletMapping + "?action=check");
request.header("Cookie", sessionCookie);
ContentResponse response2 = request.send();
assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
} finally {
client.stop();
}
} finally {
server2.stop();
}
} finally {
server1.stop();
}
}
/**
* Create the new Jetty client connector.
*
* @param jaxrsClient JAX-RS client instance, for which the connector is created.
* @param config client configuration.
*/
JettyConnector(final Client jaxrsClient, final Configuration config) {
final SSLContext sslContext = getSslContext(jaxrsClient, config);
final SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setSslContext(sslContext);
this.client = new HttpClient(sslContextFactory);
final Object connectTimeout = config.getProperties().get(ClientProperties.CONNECT_TIMEOUT);
if (connectTimeout != null
&& connectTimeout instanceof Integer
&& (Integer) connectTimeout > 0) {
client.setConnectTimeout((Integer) connectTimeout);
}
final Object threadPoolSize =
config.getProperties().get(ClientProperties.ASYNC_THREADPOOL_SIZE);
if (threadPoolSize != null
&& threadPoolSize instanceof Integer
&& (Integer) threadPoolSize > 0) {
final String name = HttpClient.class.getSimpleName() + "@" + hashCode();
final QueuedThreadPool threadPool = new QueuedThreadPool((Integer) threadPoolSize);
threadPool.setName(name);
client.setExecutor(threadPool);
}
Boolean disableCookies =
(Boolean) config.getProperties().get(JettyClientProperties.DISABLE_COOKIES);
disableCookies = (disableCookies != null) ? disableCookies : false;
final AuthenticationStore auth = client.getAuthenticationStore();
final Object basicAuthProvider =
config.getProperty(JettyClientProperties.PREEMPTIVE_BASIC_AUTHENTICATION);
if (basicAuthProvider != null && (basicAuthProvider instanceof BasicAuthentication)) {
auth.addAuthentication((BasicAuthentication) basicAuthProvider);
}
final Object proxyUri = config.getProperties().get(ClientProperties.PROXY_URI);
if (proxyUri != null) {
final URI u = getProxyUri(proxyUri);
final ProxyConfiguration proxyConfig = client.getProxyConfiguration();
proxyConfig.getProxies().add(new HttpProxy(u.getHost(), u.getPort()));
}
if (disableCookies) {
client.setCookieStore(new HttpCookieStore.Empty());
}
try {
client.start();
} catch (final Exception e) {
throw new ProcessingException("Failed to start the client.", e);
}
this.cookieStore = client.getCookieStore();
}
public HttpClient jettyHttpClient() {
if (jettyHttpClient == null) {
jettyHttpClient = new HttpClient();
try {
jettyHttpClient.start();
} catch (Exception e) {
throw new RuntimeException(e); // TODO: what to do here?
}
}
return jettyHttpClient;
}
@Override
public void onSessionInitiated(ProviderContext session) {
onem2mService = session.getRpcService(Onem2mService.class);
Onem2mNotifierService.getInstance().pluginRegistration(this);
try {
server.start();
client.start();
} catch (Exception e) {
LOG.info("Exception: {}", e.toString());
}
LOG.info("Onem2mHttpProvider Session Initiated");
}
/** @throws Exception */
public void testSessionRenewal() throws Exception {
String contextPath = "";
String servletMapping = "/server";
int maxInactive = 1;
int scavengePeriod = 3;
_server = createServer(0, maxInactive, scavengePeriod, SessionCache.NEVER_EVICT);
WebAppContext context = _server.addWebAppContext(".", contextPath);
context.setParentLoaderPriority(true);
context.addServlet(TestServlet.class, servletMapping);
TestHttpSessionIdListener testListener = new TestHttpSessionIdListener();
context.addEventListener(testListener);
HttpClient client = new HttpClient();
try {
_server.start();
int port = _server.getPort();
client.start();
// make a request to create a session
ContentResponse response =
client.GET("http://localhost:" + port + contextPath + servletMapping + "?action=create");
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
String sessionCookie = response.getHeaders().get("Set-Cookie");
assertTrue(sessionCookie != null);
assertFalse(testListener.isCalled());
// make a request to change the sessionid
Request request =
client.newRequest(
"http://localhost:" + port + contextPath + servletMapping + "?action=renew");
request.header("Cookie", sessionCookie);
ContentResponse renewResponse = request.send();
assertEquals(HttpServletResponse.SC_OK, renewResponse.getStatus());
String renewSessionCookie = renewResponse.getHeaders().get("Set-Cookie");
assertNotNull(renewSessionCookie);
assertNotSame(sessionCookie, renewSessionCookie);
assertTrue(testListener.isCalled());
assertTrue(
verifyChange(
context,
AbstractTestServer.extractSessionId(sessionCookie),
AbstractTestServer.extractSessionId(renewSessionCookie)));
} finally {
client.stop();
_server.stop();
}
}
@Test
@Ignore("failing because an http cookie with null value is coming over as \"null\"")
public void testSessionCookie() throws Exception {
String contextPath = "";
String servletMapping = "/server";
int scavengePeriod = 3;
AbstractTestServer server = createServer(0, 1, scavengePeriod);
ServletContextHandler context = server.addContext(contextPath);
context.addServlet(TestServlet.class, servletMapping);
try {
server.start();
int port = server.getPort();
HttpClient client = new HttpClient();
client.start();
try {
ContentResponse response =
client.GET(
"http://localhost:" + port + contextPath + servletMapping + "?action=create");
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
String sessionCookie = response.getHeaders().get("Set-Cookie");
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
// sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// Let's wait for the scavenger to run, waiting 2.5 times the scavenger period
// pause(scavengePeriod);
Request request =
client.newRequest(
"http://localhost:" + port + contextPath + servletMapping + "?action=check-cookie");
request.header("Cookie", sessionCookie);
response = request.send();
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
request =
client.newRequest(
"http://localhost:" + port + contextPath + servletMapping + "?action=null-cookie");
request.header("Cookie", sessionCookie);
response = request.send();
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
} finally {
client.stop();
}
} finally {
server.stop();
}
}
@Test
public void testProxyWithResponseContent() throws Exception {
prepareProxy();
HttpClient result = new HttpClient();
result
.getProxyConfiguration()
.getProxies()
.add(new HttpProxy("localhost", proxyConnector.getLocalPort()));
QueuedThreadPool threadPool = new QueuedThreadPool();
threadPool.setName("foo");
threadPool.setMaxThreads(20);
result.setExecutor(threadPool);
result.start();
ContentResponse[] responses = new ContentResponse[10];
final byte[] content = new byte[1024];
new Random().nextBytes(content);
prepareServer(
new HttpServlet() {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
if (req.getHeader("Via") != null) resp.addHeader(PROXIED_HEADER, "true");
resp.getOutputStream().write(content);
}
});
for (int i = 0; i < 10; ++i) {
// Request is for the target server
responses[i] =
result
.newRequest("localhost", serverConnector.getLocalPort())
.timeout(5, TimeUnit.SECONDS)
.send();
}
for (int i = 0; i < 10; ++i) {
Assert.assertEquals(200, responses[i].getStatus());
Assert.assertTrue(responses[i].getHeaders().containsKey(PROXIED_HEADER));
Assert.assertArrayEquals(content, responses[i].getContent());
}
}
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);
}
}
}
@Test
public void testJspDump() throws Exception {
// System.err.println("http://127.0.0.1:9876/jsp/dump.jsp sleeping....");
// Thread.currentThread().sleep(5000000);
// now test the jsp/dump.jsp
HttpClient client = new HttpClient();
try {
client.start();
ContentResponse response =
client.GET(
"http://127.0.0.1:"
+ TestJettyOSGiBootCore.DEFAULT_JETTY_HTTP_PORT
+ "/jsp/dump.jsp");
Assert.assertEquals(HttpStatus.OK_200, response.getStatus());
String content = new String(response.getContent());
System.err.println("content: " + content);
Assert.assertTrue(content.contains("<tr><th>ServletPath:</th><td>/jsp/dump.jsp</td></tr>"));
} finally {
client.stop();
}
}
@Test
public void testRemoveSession() throws Exception {
String contextPath = "";
String servletMapping = "/server";
int scavengePeriod = 3;
AbstractTestServer server = createServer(0, 1, scavengePeriod);
ServletContextHandler context = server.addContext(contextPath);
context.addServlet(TestServlet.class, servletMapping);
TestEventListener testListener = new TestEventListener();
context.getSessionHandler().addEventListener(testListener);
AbstractSessionManager m =
(AbstractSessionManager) context.getSessionHandler().getSessionManager();
try {
server.start();
int port = server.getPort();
HttpClient client = new HttpClient();
client.start();
try {
ContentResponse response =
client.GET(
"http://localhost:" + port + contextPath + servletMapping + "?action=create");
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
String sessionCookie = response.getHeaders().get("Set-Cookie");
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// ensure sessionCreated listener is called
assertTrue(testListener.isCreated());
assertEquals(1, m.getSessions());
assertEquals(1, m.getSessionsMax());
assertEquals(1, m.getSessionsTotal());
// now delete the session
Request request =
client.newRequest(
"http://localhost:" + port + contextPath + servletMapping + "?action=delete");
request.header("Cookie", sessionCookie);
response = request.send();
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
// ensure sessionDestroyed listener is called
assertTrue(testListener.isDestroyed());
assertEquals(0, m.getSessions());
assertEquals(1, m.getSessionsMax());
assertEquals(1, m.getSessionsTotal());
// The session is not there anymore, even if we present an old cookie
request =
client.newRequest(
"http://localhost:" + port + contextPath + servletMapping + "?action=check");
request.header("Cookie", sessionCookie);
response = request.send();
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
assertEquals(0, m.getSessions());
assertEquals(1, m.getSessionsMax());
assertEquals(1, m.getSessionsTotal());
} finally {
client.stop();
}
} finally {
server.stop();
}
}
@Override
public void init() throws Exception {
super.init();
if (client == null) {
client = new HttpClient(new SslContextFactory());
client.setExecutor(new ExecutorThreadPool(threadPool));
// configure timeout if set
if (connectTimeout != -1) {
client.setConnectTimeout(connectTimeout);
}
if (idleTimeout != -1) {
client.setIdleTimeout(idleTimeout);
}
client.setMaxConnectionsPerDestination(maxConnectionsPerDestination);
client.setMaxRequestsQueuedPerDestination(maxRequestsQueuedPerDestination);
// Configure SSL - if relevant
if (transportSSLEnabled) {
KeyStoreManagement keyStore =
KeyStoreManagement.getKeyStoreManagement(
httpsKeystoreType, httpsKeystore, httpsKeyPassword);
if (jmxControl != null && keyStore != null) {
jmxControl.registerMBean(
"CoUGAR:name=AsyncHttpClientKeyStore,beanName=" + beanName, keyStore);
}
KeyStoreManagement trustStore =
KeyStoreManagement.getKeyStoreManagement(
httpsTruststoreType, httpsTruststore, httpsTrustPassword);
if (jmxControl != null) {
jmxControl.registerMBean(
"CoUGAR:name=AsyncHttpClientTrustStore,beanName=" + beanName, trustStore);
}
if (trustStore == null) {
throw new IllegalStateException(
"This configuration ostensibly supports TLS, yet doesn't provide valid truststore configuration");
}
final SslContextFactory sslContextFactory = client.getSslContextFactory();
com.betfair.cougar.netutil.SslContextFactory factory =
new com.betfair.cougar.netutil.SslContextFactory();
factory.setTrustManagerFactoryKeyStore(trustStore.getKeyStore());
if (keyStore != null) {
factory.setKeyManagerFactoryKeyStore(keyStore.getKeyStore());
factory.setKeyManagerFactoryKeyStorePassword(httpsKeyPassword);
}
SSLContext context = factory.newInstance();
if (hostnameVerificationDisabled) {
context.getDefaultSSLParameters().setEndpointIdentificationAlgorithm(null);
LOGGER.warn(
"CRITICAL SECURITY CHECKS ARE DISABLED: server SSL certificate hostname "
+ "verification is turned off.");
} else {
context.getDefaultSSLParameters().setEndpointIdentificationAlgorithm("https");
}
sslContextFactory.setSslContext(context);
}
client.start();
clientCreated = true;
}
metrics = new JettyTransportMetrics();
if (jmxControl != null) {
jmxControl.registerMBean("CoUGAR:name=AsyncHttpClientExecutable,beanName=" + beanName, this);
}
}
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();
}
public EmulatorClient(String url) throws Exception {
this.url = url;
client.start();
}
@Test
public void testInvalidation() throws Exception {
String contextPath = "";
String servletMapping = "/server";
AbstractTestServer server1 = createServer(0);
server1.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
server1.start();
int port1 = server1.getPort();
System.err.println("Port1=" + port1);
try {
AbstractTestServer server2 = createServer(0);
server2.addContext(contextPath).addServlet(TestServlet.class, servletMapping);
server2.start();
int port2 = server2.getPort();
System.err.println("port2=" + port2);
try {
HttpClient client = new HttpClient();
QueuedThreadPool executor = new QueuedThreadPool();
client.setExecutor(executor);
client.start();
try {
String[] urls = new String[2];
urls[0] = "http://localhost:" + port1 + contextPath + servletMapping;
urls[1] = "http://localhost:" + port2 + contextPath + servletMapping;
// Create the session on node1
ContentResponse response1 = client.GET(urls[0] + "?action=init");
assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
String sessionCookie = response1.getHeaders().getStringField("Set-Cookie");
assertTrue(sessionCookie != null);
// Mangle the cookie, replacing Path with $Path, etc.
sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
// Be sure the session is also present in node2
Request request2 = client.newRequest(urls[1] + "?action=increment");
request2.header("Cookie", sessionCookie);
ContentResponse response2 = request2.send();
assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
// Invalidate on node1
Request request1 = client.newRequest(urls[0] + "?action=invalidate");
request1.header("Cookie", sessionCookie);
response1 = request1.send();
assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
pause();
// Be sure on node2 we don't see the session anymore
request2 = client.newRequest(urls[1] + "?action=test");
request2.header("Cookie", sessionCookie);
response2 = request2.send();
assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
} finally {
client.stop();
}
} finally {
server2.stop();
}
} finally {
server1.stop();
}
}
@Test
public void testLastAccessTime() throws Exception {
String contextPath = "";
String servletMapping = "/server";
int maxInactivePeriod = 8; // session will timeout after 8 seconds
int scavengePeriod = 2; // scavenging occurs every 2 seconds
AbstractTestServer server1 = createServer(0, maxInactivePeriod, scavengePeriod);
TestServlet servlet1 = new TestServlet();
ServletHolder holder1 = new ServletHolder(servlet1);
ServletContextHandler context = server1.addContext(contextPath);
TestSessionListener listener1 = new TestSessionListener();
context.addEventListener(listener1);
context.addServlet(holder1, 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.start();
try {
// Perform one request to server1 to create a session
Future<ContentResponse> future =
client.GET(
"http://localhost:" + port1 + contextPath + servletMapping + "?action=init");
ContentResponse response1 = future.get();
assertEquals(HttpServletResponse.SC_OK, response1.getStatus());
assertEquals("test", response1.getContentAsString());
String sessionCookie = response1.getHeaders().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) {
Request request =
client.newRequest("http://localhost:" + port2 + contextPath + servletMapping);
request.header("Cookie", sessionCookie);
future = request.send();
ContentResponse response2 = future.get();
assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
assertEquals("test", response2.getContentAsString());
String setCookie = response2.getHeaders().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);
// check that the session was not scavenged over on server1 by ensuring that the
// SessionListener destroy method wasn't called
assertTrue(listener1.destroyed == false);
} finally {
client.stop();
}
} finally {
server2.stop();
}
} finally {
server1.stop();
}
}
public static void main(String[] args) throws Exception {
// Modify host and port below to match wherever StompWebSocketServer.java is running!!
// When StompWebSocketServer starts it prints the selected available
String host = "localhost";
if (args.length > 0) {
host = args[0];
}
int port = 37232;
if (args.length > 1) {
port = Integer.valueOf(args[1]);
}
String homeUrl = "http://{host}:{port}/home";
logger.debug("Sending warm-up HTTP request to " + homeUrl);
HttpStatus status =
new RestTemplate().getForEntity(homeUrl, Void.class, host, port).getStatusCode();
Assert.state(status == HttpStatus.OK);
final CountDownLatch connectLatch = new CountDownLatch(NUMBER_OF_USERS);
final CountDownLatch subscribeLatch = new CountDownLatch(NUMBER_OF_USERS);
final CountDownLatch messageLatch = new CountDownLatch(NUMBER_OF_USERS);
final CountDownLatch disconnectLatch = new CountDownLatch(NUMBER_OF_USERS);
final AtomicReference<Throwable> failure = new AtomicReference<>();
StandardWebSocketClient webSocketClient = new StandardWebSocketClient();
HttpClient jettyHttpClient = new HttpClient();
jettyHttpClient.setMaxConnectionsPerDestination(1000);
jettyHttpClient.setExecutor(new QueuedThreadPool(1000));
jettyHttpClient.start();
List<Transport> transports = new ArrayList<>();
transports.add(new WebSocketTransport(webSocketClient));
transports.add(new JettyXhrTransport(jettyHttpClient));
SockJsClient sockJsClient = new SockJsClient(transports);
try {
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
taskScheduler.afterPropertiesSet();
String stompUrl = "ws://{host}:{port}/stomp";
WebSocketStompClient stompClient = new WebSocketStompClient(sockJsClient);
stompClient.setMessageConverter(new StringMessageConverter());
stompClient.setTaskScheduler(taskScheduler);
stompClient.setDefaultHeartbeat(new long[] {0, 0});
logger.debug("Connecting and subscribing " + NUMBER_OF_USERS + " users ");
StopWatch stopWatch = new StopWatch("STOMP Broker Relay WebSocket Load Tests");
stopWatch.start();
List<ConsumerStompSessionHandler> consumers = new ArrayList<>();
for (int i = 0; i < NUMBER_OF_USERS; i++) {
consumers.add(
new ConsumerStompSessionHandler(
BROADCAST_MESSAGE_COUNT,
connectLatch,
subscribeLatch,
messageLatch,
disconnectLatch,
failure));
stompClient.connect(stompUrl, consumers.get(i), host, port);
}
if (failure.get() != null) {
throw new AssertionError("Test failed", failure.get());
}
if (!connectLatch.await(5000, TimeUnit.MILLISECONDS)) {
fail("Not all users connected, remaining: " + connectLatch.getCount());
}
if (!subscribeLatch.await(5000, TimeUnit.MILLISECONDS)) {
fail("Not all users subscribed, remaining: " + subscribeLatch.getCount());
}
stopWatch.stop();
logger.debug("Finished: " + stopWatch.getLastTaskTimeMillis() + " millis");
logger.debug(
"Broadcasting "
+ BROADCAST_MESSAGE_COUNT
+ " messages to "
+ NUMBER_OF_USERS
+ " users ");
stopWatch.start();
ProducerStompSessionHandler producer =
new ProducerStompSessionHandler(BROADCAST_MESSAGE_COUNT, failure);
stompClient.connect(stompUrl, producer, host, port);
stompClient.setTaskScheduler(taskScheduler);
if (failure.get() != null) {
throw new AssertionError("Test failed", failure.get());
}
if (!messageLatch.await(60 * 1000, TimeUnit.MILLISECONDS)) {
for (ConsumerStompSessionHandler consumer : consumers) {
if (consumer.messageCount.get() < consumer.expectedMessageCount) {
logger.debug(consumer);
}
}
}
if (!messageLatch.await(60 * 1000, TimeUnit.MILLISECONDS)) {
fail("Not all handlers received every message, remaining: " + messageLatch.getCount());
}
producer.session.disconnect();
if (!disconnectLatch.await(5000, TimeUnit.MILLISECONDS)) {
fail("Not all disconnects completed, remaining: " + disconnectLatch.getCount());
}
stopWatch.stop();
logger.debug("Finished: " + stopWatch.getLastTaskTimeMillis() + " millis");
System.out.println("\nPress any key to exit...");
System.in.read();
} catch (Throwable t) {
t.printStackTrace();
} finally {
jettyHttpClient.stop();
}
logger.debug("Exiting");
System.exit(0);
}
@Before
public void prepare() throws Exception {
client = new HttpClient();
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();
}
}