You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by je...@apache.org on 2016/02/08 17:51:53 UTC
[05/32] incubator-geode git commit: GEODE-14: Integration of GemFire
Session Replication and Hibernate modules
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationIntegrationJUnitTest.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationIntegrationJUnitTest.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationIntegrationJUnitTest.java
new file mode 100644
index 0000000..0abd85e
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationIntegrationJUnitTest.java
@@ -0,0 +1,1558 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.internal.filter;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.concurrent.TimeUnit;
+import javax.servlet.DispatcherType;
+import javax.servlet.RequestDispatcher;
+import javax.servlet.ServletException;
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.modules.session.junit.PerTestClassLoaderRunner;
+import com.gemstone.gemfire.modules.session.filter.SessionCachingFilter;
+import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
+import org.apache.jasper.servlet.JspServlet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.eclipse.jetty.servlet.FilterHolder;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.eclipse.jetty.http.HttpTester;
+
+import static org.junit.Assert.*;
+
+/**
+ * In-container testing using Jetty. This allows us to test context listener
+ * events as well as dispatching actions.
+ */
+@Category(IntegrationTest.class)
+@RunWith(PerTestClassLoaderRunner.class)
+public class SessionReplicationIntegrationJUnitTest {
+
+ private MyServletTester tester;
+
+ private HttpTester.Request request;
+
+ private HttpTester.Response response;
+
+ private ServletHolder servletHolder;
+
+ private FilterHolder filterHolder;
+
+ private static final File tmpdir;
+
+ private static final String gemfire_log;
+
+ static {
+ // Create a per-user scratch directory
+ tmpdir = new File(System.getProperty("java.io.tmpdir"),
+ "gemfire_modules-" + System.getProperty("user.name"));
+ tmpdir.mkdirs();
+ tmpdir.deleteOnExit();
+
+ gemfire_log = tmpdir.getPath() +
+ System.getProperty("file.separator") + "gemfire_modules.log";
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ request = HttpTester.newRequest();
+
+ tester = new MyServletTester();
+ tester.setContextPath("/test");
+
+ filterHolder = tester.addFilter(SessionCachingFilter.class, "/*", EnumSet.of(DispatcherType.REQUEST));
+ filterHolder.setInitParameter("gemfire.property.mcast-port", "0");
+ filterHolder.setInitParameter("gemfire.property.log-file", gemfire_log);
+ filterHolder.setInitParameter("cache-type", "peer-to-peer");
+
+ servletHolder = tester.addServlet(BasicServlet.class, "/hello");
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ /**
+ * This starts the servlet. Our wrapped servlets *must* start
+ * immediately otherwise the ServletContext is not captured correctly.
+ */
+ servletHolder.setInitOrder(0);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+// if (tester.isStarted()) {
+// ContextManager.getInstance().removeContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+// }
+ tester.stop();
+ }
+
+ @Test
+ public void testSanity() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ PrintWriter out = response.getWriter();
+ out.write("Hello World");
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals(200, response.getStatus());
+ assertEquals("Hello World", response.getContent());
+ }
+
+ @Test
+ public void testSessionGenerated() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ PrintWriter out = response.getWriter();
+ out.write(request.getSession().getId());
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertTrue("Not a correctly generated session id",
+ response.getContent().endsWith("-GF"));
+
+ List<Cookie> cookies = getCookies(response);
+ assertEquals("Session id != JSESSIONID from cookie",
+ response.getContent(), cookies.get(0).getValue());
+
+ Region r = getRegion();
+ assertNotNull("Session not found in region",
+ r.get(cookies.get(0).getValue()));
+ }
+
+
+ /**
+ * Test that getSession(false) does not create a new session
+ */
+ @Test
+ public void testSessionNotGenerated() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ String output = "OK";
+ HttpSession s = request.getSession(false);
+ if (s != null) {
+ output = s.getId();
+ }
+ PrintWriter out = response.getWriter();
+ out.write(output);
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("Session should not have been created", "OK",
+ response.getContent());
+ }
+
+
+ @Test
+ public void testUnknownAttributeIsNull() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ Object o = request.getSession().getAttribute("unknown");
+ PrintWriter out = response.getWriter();
+ if (o == null) {
+ out.write("null");
+ } else {
+ out.write(o.toString());
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("Unknown attribute should be null", "null",
+ response.getContent());
+ }
+
+
+ @Test
+ public void testSessionRemains1() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ String output = "null";
+ HttpSession session = request.getSession();
+ if (session.isNew()) {
+ output = "new";
+ session.setAttribute("foo", output);
+ } else {
+ output = (String) session.getAttribute("foo");
+ if (output != null) {
+ output = "old";
+ }
+ }
+ PrintWriter out = response.getWriter();
+ out.write(output);
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("Session should be new", "new", response.getContent());
+
+ List<Cookie> cookies = getCookies(response);
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("Session should be old", "old", response.getContent());
+
+ List<Cookie> cookies2 = getCookies(response);
+ assertEquals("Session IDs should be the same", cookies.get(0).getValue(),
+ cookies2.get(0).getValue());
+
+ Region r = getRegion();
+ assertNotNull("Session object should exist in region",
+ r.get(cookies.get(0).getValue()));
+ }
+
+ /**
+ * Test that attributes are updated on the backend
+ */
+ @Test
+ public void testAttributesUpdatedInRegion() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ request.getSession().setAttribute("foo", "bar");
+ }
+ };
+
+ // This is the callback used to invalidate the session
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ request.getSession().setAttribute("foo", "baz");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ ServletHolder sh2 = tester.addServlet(BasicServlet.class, "/request2");
+ sh2.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ List<Cookie> cookies = getCookies(response);
+
+ Region r = getRegion();
+ assertEquals("bar",
+ ((HttpSession) r.get(cookies.get(0).getValue())).getAttribute("foo"));
+
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+ request.setURI("/test/request2");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("baz",
+ ((HttpSession) r.get(cookies.get(0).getValue())).getAttribute(
+ "foo"));
+ }
+
+ /**
+ * Test setting an attribute to null deletes it
+ */
+ @Test
+ public void testSetAttributeNullDeletesIt() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ request.getSession().setAttribute("foo", "bar");
+ }
+ };
+
+ // This is the callback used to invalidate the session
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ request.getSession().setAttribute("foo", null);
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ ServletHolder sh2 = tester.addServlet(BasicServlet.class, "/request2");
+ sh2.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ List<Cookie> cookies = getCookies(response);
+
+ Region r = getRegion();
+ assertEquals("bar",
+ ((HttpSession) r.get(cookies.get(0).getValue())).getAttribute(
+ "foo"));
+
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+ request.setURI("/test/request2");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertNull(
+ ((HttpSession) r.get(cookies.get(0).getValue())).getAttribute(
+ "foo"));
+ }
+
+// Don't see how to do this currently as the SessionListener needs a full
+// web context to work in.
+
+// /**
+// * Test that sessions expire correctly
+// */
+// public void testSessionExpiration() throws Exception {
+// Callback c_1 = new Callback() {
+// @Override
+// public void call(HttpServletRequest request, HttpServletResponse response)
+// throws IOException, ServletException {
+// HttpSession s = request.getSession();
+// s.setAttribute("foo", "bar");
+// s.setMaxInactiveInterval(1);
+//
+// PrintWriter out = response.getWriter();
+// out.write(s.getId());
+// }
+// };
+//
+// // This is the callback used to check if the session is still there
+// Callback c_2 = new Callback() {
+// @Override
+// public void call(HttpServletRequest request, HttpServletResponse response)
+// throws IOException, ServletException {
+// HttpSession s = request.getSession(false);
+// String output;
+// if (s == null) {
+// output = "null";
+// } else {
+// output = s.getId();
+// }
+//
+// PrintWriter out = response.getWriter();
+// out.write(output);
+// }
+// };
+//
+// tester.addEventListener(new SessionListener());
+// tester.setAttribute("callback_1", c_1);
+// tester.setAttribute("callback_2", c_2);
+//
+// servletHolder.setInitParameter("test.callback", "callback_1");
+//
+// ServletHolder sh2 = tester.addServlet(BasicServlet.class, "/request2");
+// sh2.setInitParameter("test.callback", "callback_2");
+//
+// tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+//
+// request.setMethod("GET");
+// request.setURI("/test/hello");
+// request.setHeader("Host", "tester");
+// request.setVersion("HTTP/1.0");
+// response.parse(tester.getResponses(request.generate()));
+//
+// String id = response.getContent();
+//
+// // Wait for the session to expire
+// Thread.sleep(2000);
+//
+// request.setHeader("Cookie", "JSESSIONID=" + id);
+// request.setURI("/test/request2");
+// response.parse(tester.getResponses(request.generate()));
+//
+// assertEquals("null", response.getContent());
+//
+// Region r = getRegion();
+// assertNull("Region should not contain session", r.get(id));
+// }
+
+ /**
+ * Test that invalidating a session destroys it as well as the backend
+ * object.
+ */
+ @Test
+ public void testInvalidateSession1() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ request.getSession().setAttribute("foo", "bar");
+ }
+ };
+
+ // This is the callback used to invalidate the session
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ request.getSession(false).invalidate();
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ ServletHolder sh2 = tester.addServlet(BasicServlet.class, "/request2");
+ sh2.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ List<Cookie> cookies = getCookies(response);
+ Region r = getRegion();
+ assertEquals("bar",
+ ((HttpSession) r.get(cookies.get(0).getValue())).getAttribute("foo"));
+
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+ request.setURI("/test/request2");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertNull("Region should not contain session",
+ r.get(cookies.get(0).getValue()));
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession2() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.getAttribute("foo");
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession3() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.getAttributeNames();
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession4() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.getCreationTime();
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session does not throw an exception for subsequent
+ * getId calls.
+ */
+ @Test
+ public void testInvalidateSession5() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ s.getId();
+ PrintWriter out = response.getWriter();
+ out.write("OK");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession6() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.getLastAccessedTime();
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session does not throw an exception for
+ * subsequent getMaxInactiveInterval calls.
+ */
+
+// I've commented this out for now as Jetty seems to want to throw an
+// Exception here where the HttpServlet api doesn't specify that.
+ @Test
+ public void testInvalidateSession7() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request,
+ HttpServletResponse response) throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ s.getMaxInactiveInterval();
+ PrintWriter out = response.getWriter();
+ out.write("OK");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session does not throw an exception for subsequent
+ * getServletContext calls.
+ */
+ @Test
+ public void testInvalidateSession8() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ s.getServletContext();
+ PrintWriter out = response.getWriter();
+ out.write("OK");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession9() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.isNew();
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession10() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.removeAttribute("foo");
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session throws an exception on subsequent access.
+ */
+ @Test
+ public void testInvalidateSession11() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ PrintWriter out = response.getWriter();
+ try {
+ s.setAttribute("foo", "bar");
+ } catch (IllegalStateException iex) {
+ out.write("OK");
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session does not throw an exception for subsequent
+ * setMaxInactiveInterval calls.
+ */
+ @Test
+ public void testInvalidateSession12() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ s.setMaxInactiveInterval(1);
+ PrintWriter out = response.getWriter();
+ out.write("OK");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+ /**
+ * Test that invalidating a session results in null being returned on
+ * subsequent getSession(false) calls.
+ */
+ @Test
+ public void testInvalidateSession13() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+ s = request.getSession(false);
+ PrintWriter out = response.getWriter();
+ if (s == null) {
+ out.write("OK");
+ } else {
+ out.write(s.toString());
+ }
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+
+ servletHolder.setInitParameter("test.callback", "callback_1");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("OK", response.getContent());
+ }
+
+
+ /**
+ * Test that we can invalidate and then recreate a new session
+ */
+ @Test
+ public void testInvalidateAndRecreateSession() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+
+ PrintWriter out = response.getWriter();
+ out.write(request.getSession().getId());
+ }
+ };
+
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.invalidate();
+
+ PrintWriter out = response.getWriter();
+ out.write(request.getSession().getId());
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ ServletHolder sh = tester.addServlet(BasicServlet.class, "/dispatch");
+ sh.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// sh.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ String session1 = response.getContent();
+
+ request.setHeader("Cookie", "JSESSIONID=" + session1);
+ request.setURI("/test/request2");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ String session12 = response.getContent();
+ assertFalse("First and subsequent session ids must not be the same",
+ session1.equals(session12));
+ }
+
+
+ /**
+ * Test that creation time does not change on subsequent access
+ */
+ @Test
+ public void testGetCreationTime() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession session = request.getSession();
+ PrintWriter out = response.getWriter();
+ out.write(Long.toString(session.getCreationTime()));
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ long time1 = Long.parseLong(response.getContent());
+ assertTrue("Creation time should be positive", time1 > 0);
+
+ List<Cookie> cookies = getCookies(response);
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+
+ try {
+ Thread.sleep(1000);
+ } catch (Exception ex) {
+ }
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ long time2 = Long.parseLong(response.getContent());
+ assertTrue("Creation time should be the same across requests",
+ time1 == time2);
+ }
+
+ /**
+ * Test that the last accessed time is updated on subsequent access
+ */
+ @Test
+ public void testGetLastAccessedTime() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession session = request.getSession();
+ PrintWriter out = response.getWriter();
+ out.write(Long.toString(session.getLastAccessedTime()));
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ long time1 = Long.parseLong(response.getContent());
+// assertTrue("Last accessed time should be positive", time1 > 0);
+
+ List<Cookie> cookies = getCookies(response);
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+
+ Thread.sleep(1000);
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ long time2 = Long.parseLong(response.getContent());
+ assertTrue("Last accessed time should be increasing across requests",
+ time2 > time1);
+ }
+
+ /**
+ * Test that the underlying native session remains the same across requests
+ */
+ @Test
+ public void testNativeSessionRemainsUnchanged() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ GemfireHttpSession session = (GemfireHttpSession) request.getSession();
+ PrintWriter out = response.getWriter();
+ out.write(session.getNativeSession().getId());
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ String nativeSessionId = response.getContent();
+
+ List<Cookie> cookies = getCookies(response);
+ String sessionId = cookies.get(0).getValue();
+ Region r = getRegion();
+
+ assertEquals(
+ "Cached native session id does not match servlet returned native session id",
+ nativeSessionId,
+ ((GemfireHttpSession) r.get(sessionId)).getNativeSession().getId());
+
+ request.setHeader("Cookie", "JSESSIONID=" + cookies.get(0).getValue());
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals(
+ "Underlying native sessions must remain the same across requests",
+ nativeSessionId,
+ ((GemfireHttpSession) r.get(sessionId)).getNativeSession().getId());
+ }
+
+ /**
+ * Test session id embedded in the URL
+ */
+ @Test
+ public void testSessionIdEmbeddedInUrl() throws Exception {
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ GemfireHttpSession session = (GemfireHttpSession) request.getSession();
+ PrintWriter out = response.getWriter();
+ out.write(session.getId());
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ List<Cookie> cookies = getCookies(response);
+ String sessionId = response.getContent();
+ assertEquals("Session ids should be the same", sessionId,
+ cookies.get(0).getValue());
+
+ request.setURI("/test/hello;jsessionid=" + sessionId);
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ cookies = getCookies(response);
+
+ assertEquals("Session ids should be the same", sessionId,
+ cookies.get(0).getValue());
+ }
+
+
+ /**
+ * Test that request forward dispatching works
+ */
+ @Test
+ public void testDispatchingForward1() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ RequestDispatcher dispatcher = request.getRequestDispatcher("dispatch");
+ dispatcher.forward(request, response);
+
+ // This should not appear in the output
+ PrintWriter out = response.getWriter();
+ out.write("bang");
+ }
+ };
+
+ // This is the callback used by the forward servlet
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ PrintWriter out = response.getWriter();
+ out.write("dispatched");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ ServletHolder sh = tester.addServlet(BasicServlet.class, "/dispatch");
+ sh.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// sh.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ assertEquals("dispatched", response.getContent());
+
+// ContextManager.getInstance().removeContext(
+// sh.getServlet().getServletConfig().getServletContext());
+ }
+
+
+ /**
+ * Test that request include dispatching works
+ */
+ @Test
+ public void testDispatchingInclude() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ RequestDispatcher dispatcher = request.getRequestDispatcher("dispatch");
+ dispatcher.include(request, response);
+
+ // This *should* appear in the output
+ PrintWriter out = response.getWriter();
+ out.write("_bang");
+ }
+ };
+
+ // This is the callback used by the include servlet
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ PrintWriter out = response.getWriter();
+ out.write("dispatched");
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ ServletHolder sh = tester.addServlet(BasicServlet.class, "/dispatch");
+ sh.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// sh.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ assertEquals("dispatched_bang", response.getContent());
+
+// ContextManager.getInstance().removeContext(
+// sh.getServlet().getServletConfig().getServletContext());
+ }
+
+
+ /**
+ * Test to try and simulate a failover scenario
+ */
+ @Test
+ public void testFailover1() throws Exception {
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ HttpSession s = request.getSession();
+ s.setAttribute("foo", "bar");
+
+ PrintWriter out = response.getWriter();
+ out.write(request.getSession().getId());
+ }
+ };
+
+ Callback c_2 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ HttpSession s = request.getSession();
+
+ PrintWriter out = response.getWriter();
+ out.write((String) s.getAttribute("foo"));
+ }
+ };
+
+ tester.setAttribute("callback_1", c_1);
+ tester.setAttribute("callback_2", c_2);
+
+ ServletHolder sh = tester.addServlet(BasicServlet.class, "/request2");
+ sh.setInitParameter("test.callback", "callback_2");
+
+ tester.start();
+// ContextManager.getInstance().putContext(
+// sh.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+ String id = response.getContent();
+
+ // Now we simulate the failover by removing the native session from
+ // the stored session
+ Region r = getRegion();
+ GemfireHttpSession sessObj = (GemfireHttpSession) r.get(id);
+ sessObj.setNativeSession(null);
+
+ r.put(id, sessObj);
+
+ request.setHeader("Cookie", "JSESSIONID=" + id);
+ request.setURI("/test/request2");
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals("bar", response.getContent());
+ }
+
+ @Test
+ public void testHttpSessionListener1() throws Exception {
+ HttpSessionListenerImpl listener = new HttpSessionListenerImpl();
+ tester.getContext().getSessionHandler().addEventListener(listener);
+
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ // This is set in HttpSessionListenerImpl
+ String result = (String) s.getAttribute("gemfire-session-id");
+ response.getWriter().write(result);
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals(200, response.getStatus());
+
+ List<Cookie> cookies = getCookies(response);
+
+// AbstractListener listener = RendezvousManager.getListener();
+ tester.stop();
+
+ assertTrue("Timeout waiting for events",
+ listener.await(1, TimeUnit.SECONDS));
+ assertEquals(ListenerEventType.SESSION_CREATED,
+ listener.events.get(0));
+ assertEquals(ListenerEventType.SESSION_DESTROYED,
+ listener.events.get(1));
+ assertEquals(cookies.get(0).getValue(), response.getContent());
+ }
+
+ @Test
+ public void testHttpSessionListener2() throws Exception {
+ HttpSessionListenerImpl2 listener = new HttpSessionListenerImpl2();
+ tester.getContext().getSessionHandler().addEventListener(listener);
+
+ Callback c = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ HttpSession s = request.getSession();
+ s.setAttribute("test01", "test01");
+ s = request.getSession(false);
+ s.invalidate();
+ response.getWriter().write(s.getId());
+ }
+ };
+
+ tester.setAttribute("callback_1", c);
+ tester.start();
+// ContextManager.getInstance().putContext(
+// servletHolder.getServlet().getServletConfig().getServletContext());
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals(200, response.getStatus());
+
+ List<Cookie> cookies = getCookies(response);
+
+ tester.stop();
+
+ assertTrue("Timeout waiting for events",
+ listener.await(1, TimeUnit.SECONDS));
+ assertEquals(ListenerEventType.SESSION_CREATED,
+ listener.events.get(0));
+ assertEquals(ListenerEventType.SESSION_DESTROYED,
+ listener.events.get(1));
+ assertEquals(cookies.get(0).getValue(), response.getContent());
+ }
+
+
+
+
+// @Test
+ public void testJsp() throws Exception {
+ tester.setResourceBase("target/test-classes");
+ ServletHolder jspHolder = tester.addServlet(JspServlet.class, "/test/*");
+ jspHolder.setInitOrder(1);
+
+ jspHolder.setInitParameter("scratchdir", tmpdir.getPath());
+
+ Callback c_1 = new Callback() {
+ @Override
+ public void call(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ request.getSession().setAttribute("foo", "bar");
+ request.setAttribute("foo", "baz");
+ RequestDispatcher dispatcher = request.getRequestDispatcher(
+ "pagecontext.jsp");
+ dispatcher.forward(request, response);
+ }
+ };
+
+ tester.getContext().setClassLoader(Thread.currentThread().getContextClassLoader());
+ tester.setAttribute("callback_1", c_1);
+
+ tester.start();
+
+ request.setMethod("GET");
+ request.setURI("/test/hello");
+ request.setHeader("Host", "tester");
+ request.setVersion("HTTP/1.0");
+
+ response = HttpTester.parseResponse(tester.getResponses(request.generate()));
+
+ assertEquals(200, response.getStatus());
+ assertEquals("baz", response.getContent().trim());
+ }
+
+
+ ////////////////////////////////////////////////////////////////////
+ // Private methods
+
+ /**
+ * Why doesn't HttpTester do this already??
+ */
+ private List<Cookie> getCookies(HttpTester.Response response) {
+ List<Cookie> cookies = new ArrayList<Cookie>();
+
+ Enumeration e = response.getValues("Set-Cookie");
+
+ while (e != null && e.hasMoreElements()) {
+ String header = (String) e.nextElement();
+ Cookie c = null;
+
+ StringTokenizer st = new StringTokenizer(header, ";");
+ while (st.hasMoreTokens()) {
+ String[] split = st.nextToken().split("=");
+ String param = split[0].trim();
+ String value = null;
+ if (split.length > 1) {
+ value = split[1].trim();
+ }
+ if ("version".equalsIgnoreCase(param)) {
+ c.setVersion(Integer.parseInt(value));
+ } else if ("comment".equalsIgnoreCase(param)) {
+ c.setComment(value);
+ } else if ("domain".equalsIgnoreCase(param)) {
+ c.setDomain(value);
+ } else if ("max-age".equalsIgnoreCase(param)) {
+ c.setMaxAge(Integer.parseInt(value));
+ } else if ("discard".equalsIgnoreCase(param)) {
+ c.setMaxAge(-1);
+ } else if ("path".equalsIgnoreCase(param)) {
+ c.setPath(value);
+ } else if ("secure".equalsIgnoreCase(param)) {
+ c.setSecure(true);
+ } else if ("httponly".equalsIgnoreCase(param)) {
+ // Ignored??
+ } else {
+ if (c == null) {
+ c = new Cookie(param, value);
+ } else {
+ throw new IllegalStateException("Unknown cookie param: " + param);
+ }
+ }
+ }
+
+ if (c != null) {
+ cookies.add(c);
+ }
+ }
+
+ return cookies;
+ }
+
+ private Region getRegion() {
+ // Yuck...
+ return ((GemfireSessionManager) ((SessionCachingFilter) filterHolder.getFilter()).getSessionManager()).getCache().getCache().getRegion(
+ "gemfire_modules_sessions");
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationJUnitTest.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationJUnitTest.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationJUnitTest.java
new file mode 100644
index 0000000..ba4cbd9
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationJUnitTest.java
@@ -0,0 +1,53 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.internal.filter;
+
+import com.gemstone.gemfire.modules.session.filter.SessionCachingFilter;
+import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
+import com.mockrunner.mock.web.MockFilterConfig;
+import com.mockrunner.mock.web.WebMockObjectFactory;
+import org.junit.Before;
+import org.junit.experimental.categories.Category;
+
+/**
+ * This runs all tests with a local cache disabled
+ */
+@Category(IntegrationTest.class)
+public class SessionReplicationJUnitTest extends CommonTests {
+
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+
+ WebMockObjectFactory factory = getWebMockObjectFactory();
+ MockFilterConfig config = factory.getMockFilterConfig();
+
+ config.setInitParameter("gemfire.property.mcast-port", "0");
+ config.setInitParameter("cache-type", "peer-to-peer");
+
+ factory.getMockServletContext().setContextPath(CONTEXT_PATH);
+
+ factory.getMockRequest().setRequestURL("/test/foo/bar");
+ factory.getMockRequest().setContextPath(CONTEXT_PATH);
+
+ createFilter(SessionCachingFilter.class);
+ createServlet(CallbackServlet.class);
+
+ setDoChain(true);
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationLocalCacheJUnitTest.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationLocalCacheJUnitTest.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationLocalCacheJUnitTest.java
new file mode 100644
index 0000000..4016c7c
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/internal/filter/SessionReplicationLocalCacheJUnitTest.java
@@ -0,0 +1,54 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.internal.filter;
+
+import com.gemstone.gemfire.modules.session.filter.SessionCachingFilter;
+import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
+import com.mockrunner.mock.web.MockFilterConfig;
+import com.mockrunner.mock.web.WebMockObjectFactory;
+import org.junit.Before;
+import org.junit.experimental.categories.Category;
+
+/**
+ * This runs all tests with a local cache enabled
+ */
+@Category(IntegrationTest.class)
+public class SessionReplicationLocalCacheJUnitTest extends CommonTests {
+
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+
+ WebMockObjectFactory factory = getWebMockObjectFactory();
+ MockFilterConfig config = factory.getMockFilterConfig();
+
+ config.setInitParameter("gemfire.property.mcast-port", "0");
+ config.setInitParameter("cache-type", "peer-to-peer");
+ config.setInitParameter("gemfire.cache.enable_local_cache", "true");
+
+ factory.getMockServletContext().setContextPath(CONTEXT_PATH);
+
+ factory.getMockRequest().setRequestURL("/test/foo/bar");
+ factory.getMockRequest().setContextPath(CONTEXT_PATH);
+
+ createFilter(SessionCachingFilter.class);
+ createServlet(CallbackServlet.class);
+
+ setDoChain(true);
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/ChildFirstClassLoader.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/ChildFirstClassLoader.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/ChildFirstClassLoader.java
new file mode 100644
index 0000000..dd4441b
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/ChildFirstClassLoader.java
@@ -0,0 +1,86 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.junit;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+public class ChildFirstClassLoader extends URLClassLoader {
+
+ public ChildFirstClassLoader() {
+ super(new URL[]{});
+ }
+
+ public ChildFirstClassLoader(URL[] urls) {
+ super(urls);
+ }
+
+ public ChildFirstClassLoader(URL[] urls, ClassLoader parent) {
+ super(urls, parent);
+ }
+
+ @Override
+ public void addURL(URL url) {
+ super.addURL(url);
+ }
+
+ @Override
+ public Class loadClass(String name) throws ClassNotFoundException {
+ return loadClass(name, false);
+ }
+
+ /**
+ * We override the parent-first behavior established by
+ * java.lang.Classloader.
+ */
+ @Override
+ protected Class loadClass(String name, boolean resolve)
+ throws ClassNotFoundException {
+ Class c = null;
+
+ if (name.startsWith("com.gemstone")) {
+ // First, check if the class has already been loaded
+ c = findLoadedClass(name);
+
+ // if not loaded, search the local (child) resources
+ if (c == null) {
+ try {
+ c = findClass(name);
+ } catch (ClassNotFoundException cnfe) {
+ // ignore
+ }
+ }
+ }
+
+ // if we could not find it, delegate to parent
+ // Note that we don't attempt to catch any ClassNotFoundException
+ if (c == null) {
+ if (getParent() != null) {
+ c = getParent().loadClass(name);
+ } else {
+ c = getSystemClassLoader().loadClass(name);
+ }
+ }
+
+ if (resolve) {
+ resolveClass(c);
+ }
+
+ return c;
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/NamedRunner.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/NamedRunner.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/NamedRunner.java
new file mode 100644
index 0000000..e717c9a
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/NamedRunner.java
@@ -0,0 +1,120 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.junit;
+
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+
+/**
+ * A Junit 4 runner that stores the name of the method that runs. The methods
+ * marked with @After and @Before (but also the Test method itself) can request
+ * this name for which it is running.
+ *
+ * @author Rudy De Busscher
+ */
+public class NamedRunner extends BlockJUnit4ClassRunner {
+
+ /**
+ * The Constant PREFIX_KEY.
+ */
+ private static final String PREFIX_KEY = "ClassLoaderRunner_TestMethodName_";
+
+ /**
+ * The Constant NO_NAME.
+ */
+ private static final String NO_NAME = "null";
+
+ /**
+ * Instantiates a new named runner.
+ *
+ * @param klass the klass
+ * @throws InitializationError the initialization error
+ */
+ public NamedRunner(Class<?> klass) throws InitializationError {
+ super(klass);
+ }
+
+ @Override
+ protected void runChild(FrameworkMethod method, RunNotifier notifier)
+
+ {
+ storeTestMethodName(method.getName());
+ super.runChild(method, notifier);
+ removeTestMethodName();
+ }
+
+ /**
+ * Gets the test method name.
+ *
+ * @return the test method name
+ */
+ public static String getTestMethodName() {
+ return retrieveTestMethodName();
+ }
+
+ /**
+ * Retrieve test method name.
+ *
+ * @return the string
+ */
+ private static String retrieveTestMethodName() {
+ // We can't use a ThreadLocal variable in the case the TestPerClassLoader runner is used. Then this
+ // Method is accessed from another classloader and thus reinitialized variables.
+ String result = null;
+ String storedName = System.getProperty(getKey());
+ if (!NO_NAME.equals(storedName)) {
+ result = storedName;
+ }
+ return result;
+ }
+
+ /**
+ * Removes the test method name.
+ */
+ private static void removeTestMethodName() {
+ // We can't use a ThreadLocal variable in the case the TestPerClassLoader runner is used. Then this
+ // Method is accessed from another classloader and thus reinitialized variables.
+ System.setProperty(getKey(), NO_NAME);
+
+ }
+
+ /**
+ * Store test method name.
+ *
+ * @param name the name
+ */
+ private static void storeTestMethodName(String name) {
+
+ // We can't use a ThreadLocal variable in the case the TestPerClassLoader runner is used. Then this
+ // Method is accessed from another classloader and thus reinitialized variables.
+ System.setProperty(getKey(), name);
+ }
+
+ /**
+ * Gets the key.
+ *
+ * @return the key
+ */
+ private static String getKey() {
+ StringBuffer buffer = new StringBuffer();
+ buffer.append(PREFIX_KEY).append(Thread.currentThread().getName());
+ return buffer.toString();
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/PerTestClassLoaderRunner.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/PerTestClassLoaderRunner.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/PerTestClassLoaderRunner.java
new file mode 100644
index 0000000..3e5c998
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/PerTestClassLoaderRunner.java
@@ -0,0 +1,283 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.junit;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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
+ * <p/>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p/>
+ * 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.
+ */
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.internal.runners.statements.Fail;
+import org.junit.internal.runners.statements.RunAfters;
+import org.junit.internal.runners.statements.RunBefores;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.logging.Logger;
+
+public class PerTestClassLoaderRunner extends NamedRunner {
+ private static final Logger LOGGER = Logger
+ .getLogger(PerTestClassLoaderRunner.class.getName());
+
+ // The classpath is needed because the custom class loader looks there to find the classes.
+ private static String classPath;
+ private static boolean classPathDetermined = false;
+
+ // Some data related to the class from the custom class loader.
+ private TestClass testClassFromClassLoader;
+ private Object beforeFromClassLoader;
+ private Object afterFromClassLoader;
+
+ /**
+ * Instantiates a new test per class loader runner.
+ *
+ * @param klass the klass
+ * @throws InitializationError the initialization error
+ */
+ public PerTestClassLoaderRunner(Class<?> klass) throws InitializationError {
+ super(klass);
+ }
+
+ @Override
+ protected Object createTest() throws Exception {
+ // Need an instance now from the class loaded by the custom loader.
+ return testClassFromClassLoader.getJavaClass().newInstance();
+ }
+
+ /**
+ * Load classes (TestCase, @Before and @After with custom class loader.
+ *
+ * @throws ClassNotFoundException the class not found exception
+ */
+ private void loadClassesWithCustomClassLoader()
+ throws ClassNotFoundException {
+ String classPath = System.getProperty("java.class.path");
+ StringTokenizer st = new StringTokenizer(classPath, ":");
+ List<URL> urls = new ArrayList<URL>();
+ while (st.hasMoreTokens()) {
+ String u = st.nextToken();
+ try {
+ if (!u.endsWith(".jar")) {
+ u += "/";
+ }
+ URL url = new URL("file://" + u);
+ urls.add(url);
+ } catch (MalformedURLException e) {
+ e.printStackTrace();
+ }
+ }
+
+ ClassLoader classLoader = new ChildFirstClassLoader(
+ urls.toArray(new URL[]{}),
+ Thread.currentThread().getContextClassLoader()
+ );
+
+ Thread.currentThread().setContextClassLoader(classLoader);
+
+ testClassFromClassLoader = new TestClass(classLoader
+ .loadClass(getTestClass().getJavaClass().getName()));
+ // See withAfters and withBefores for the reason.
+ beforeFromClassLoader = classLoader.loadClass(Before.class.getName());
+ afterFromClassLoader = classLoader.loadClass(After.class.getName());
+ }
+
+ @Override
+ protected Statement methodBlock(FrameworkMethod method) {
+ FrameworkMethod newMethod = null;
+ try {
+ // Need the class from the custom loader now, so lets load the class.
+ loadClassesWithCustomClassLoader();
+ // The method as parameter is from the original class and thus not found in our
+ // class loaded by the custom name (reflection is class loader sensitive)
+ // So find the same method but now in the class from the class Loader.
+ Method methodFromNewlyLoadedClass = testClassFromClassLoader
+ .getJavaClass().getMethod(method.getName());
+ newMethod = new FrameworkMethod(methodFromNewlyLoadedClass);
+ } catch (ClassNotFoundException e) {
+ // Show any problem nicely as a JUnit Test failure.
+ return new Fail(e);
+ } catch (SecurityException e) {
+ return new Fail(e);
+ } catch (NoSuchMethodException e) {
+ return new Fail(e);
+ }
+
+ // We can carry out the normal JUnit functionality with our newly discovered method now.
+ return super.methodBlock(newMethod);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ protected Statement withAfters(FrameworkMethod method, Object target,
+ Statement statement) {
+ // We now to need to search in the class from the custom loader.
+ // We also need to search with the annotation loaded by the custom
+ // class loader or otherwise we don't find any method.
+ List<FrameworkMethod> afters = testClassFromClassLoader
+ .getAnnotatedMethods(
+ (Class<? extends Annotation>) afterFromClassLoader);
+ return new RunAfters(statement, afters, target);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ protected Statement withBefores(FrameworkMethod method, Object target,
+ Statement statement) {
+ // We now to need to search in the class from the custom loader.
+ // We also need to search with the annotation loaded by the custom
+ // class loader or otherwise we don't find any method.
+ List<FrameworkMethod> befores = testClassFromClassLoader
+ .getAnnotatedMethods(
+ (Class<? extends Annotation>) beforeFromClassLoader);
+ return new RunBefores(statement, befores, target);
+ }
+
+// /**
+// * Gets the class path. This value is cached in a static variable for performance reasons.
+// *
+// * @return the class path
+// */
+// private static String getClassPath()
+// {
+// if (classPathDetermined)
+// {
+// return classPath;
+// }
+//
+// classPathDetermined = true;
+// // running from maven, we have the classpath in this property.
+// classPath = System.getProperty("surefire.test.class.path");
+// if (classPath != null)
+// {
+// return classPath;
+// }
+//
+// // For a multi module project, running it from the top we have to find it using another way.
+// // We also need to set useSystemClassLoader=true in the POM so that we gets a jar with the classpath in it.
+// String booterClassPath = System.getProperty("java.class.path");
+// Vector<String> pathItems = null;
+// if (booterClassPath != null)
+// {
+// pathItems = scanPath(booterClassPath);
+// }
+// // Do we have just 1 entry as classpath which is a jar?
+// if (pathItems != null && pathItems.size() == 1
+// && isJar((String) pathItems.get(0)))
+// {
+// classPath = loadJarManifestClassPath((String) pathItems.get(0),
+// "META-INF/MANIFEST.MF");
+// }
+// return classPath;
+//
+// }
+
+// /**
+// * Load jar manifest class path.
+// *
+// * @param path the path
+// * @param fileName the file name
+// *
+// * @return the string
+// */
+// private static String loadJarManifestClassPath(String path, String fileName)
+// {
+// File archive = new File(path);
+// if (!archive.exists()) {
+// return null;
+// }
+// ZipFile zipFile = null;
+//
+// try {
+// zipFile = new ZipFile(archive);
+// } catch (IOException io) {
+// return null;
+// }
+//
+// ZipEntry entry = zipFile.getEntry(fileName);
+// if (entry == null) {
+// return null;
+// } try {
+// Manifest mf = new Manifest();
+// mf.read(zipFile.getInputStream(entry));
+//
+// return mf.getMainAttributes().getValue(Attributes.Name.CLASS_PATH)
+// .replaceAll(" ", System.getProperty("path.separator"))
+// .replaceAll("file:/", "");
+// } catch (MalformedURLException e) {
+// LOGGER.throwing("ClassLoaderTestSuite", "loadJarManifestClassPath", e);
+// } catch (IOException e) {
+// LOGGER.throwing("ClassLoaderTestSuite", "loadJarManifestClassPath", e);
+// }
+// return null;
+// }
+//
+// /**
+// * Checks if is jar.
+// *
+// * @param pathEntry the path entry
+// *
+// * @return true, if is jar
+// */
+// private static boolean isJar(String pathEntry)
+// {
+// return pathEntry.endsWith(".jar") || pathEntry.endsWith(".zip");
+// }
+//
+// /**
+// * Scan path for all directories.
+// *
+// * @param classPath the class path
+// *
+// * @return the vector< string>
+// */
+// private static Vector<String> scanPath(String classPath)
+// {
+// String separator = System.getProperty("path.separator");
+// Vector<String> pathItems = new Vector<String>(10);
+// StringTokenizer st = new StringTokenizer(classPath, separator);
+// while (st.hasMoreTokens())
+// {
+// pathItems.addElement(st.nextToken());
+// }
+// return pathItems;
+// }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/SeparateClassloaderTestRunner.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/SeparateClassloaderTestRunner.java b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/SeparateClassloaderTestRunner.java
new file mode 100644
index 0000000..4337f5a
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/java/com/gemstone/gemfire/modules/session/junit/SeparateClassloaderTestRunner.java
@@ -0,0 +1,56 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.junit;
+
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.InitializationError;
+
+import java.net.URLClassLoader;
+
+/**
+ * @author StackOverflow
+ */
+public class SeparateClassloaderTestRunner extends BlockJUnit4ClassRunner {
+
+ public SeparateClassloaderTestRunner(Class<?> clazz) throws InitializationError {
+ super(getFromTestClassloader(clazz));
+ }
+
+ private static Class<?> getFromTestClassloader(Class<?> clazz) throws InitializationError {
+ try {
+ ClassLoader testClassLoader = new TestClassLoader();
+ return Class.forName(clazz.getName(), true, testClassLoader);
+ } catch (ClassNotFoundException e) {
+ throw new InitializationError(e);
+ }
+ }
+
+ public static class TestClassLoader extends URLClassLoader {
+ public TestClassLoader() {
+ super(((URLClassLoader)getSystemClassLoader()).getURLs());
+ }
+
+ @Override
+ public Class<?> loadClass(String name) throws ClassNotFoundException {
+ if (name.startsWith("com.gemstone.gemfire.modules.session.")) {
+ return super.findClass(name);
+ }
+ return super.loadClass(name);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-session/src/test/resources/log4j.properties
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-session/src/test/resources/log4j.properties b/extensions/gemfire-modules-session/src/test/resources/log4j.properties
new file mode 100644
index 0000000..b346714
--- /dev/null
+++ b/extensions/gemfire-modules-session/src/test/resources/log4j.properties
@@ -0,0 +1,12 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+# Set root logger level to DEBUG and its only appender to A1.
+log4j.rootLogger=DEBUG, A1
+
+# A1 is set to be a ConsoleAppender.
+log4j.appender.A1=org.apache.log4j.ConsoleAppender
+
+# A1 uses PatternLayout.
+log4j.appender.A1.layout=org.apache.log4j.PatternLayout
+log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-tomcat7/build.gradle
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-tomcat7/build.gradle b/extensions/gemfire-modules-tomcat7/build.gradle
new file mode 100644
index 0000000..10b8803
--- /dev/null
+++ b/extensions/gemfire-modules-tomcat7/build.gradle
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+test {
+ doFirst {
+ copy {
+ from 'build/resources/test/tomcat'
+ into 'build/test/tomcat/'
+ }
+ }
+}
+
+jar {
+ baseName = 'gemfire-modules-tomcat7'
+}
+
+dependencies {
+ compile(project(':extensions/gemfire-modules')) {
+ // Remove everything related to Tomcat 6.x
+ exclude group: 'org.apache.tomcat'
+ }
+
+ compile 'org.apache.tomcat:tomcat-api:' + project.'tomcat7.version'
+ compile 'org.apache.tomcat:tomcat-catalina:' + project.'tomcat7.version'
+ compile 'org.apache.tomcat:tomcat-coyote:' + project.'tomcat7.version'
+ compile 'org.apache.tomcat:tomcat-util:' + project.'tomcat7.version'
+ compile 'org.apache.tomcat:tomcat-juli:' + project.'tomcat7.version'
+
+ testCompile 'org.httpunit:httpunit:' + project.'httpunit.version'
+ testRuntime 'javax.servlet:javax.servlet-api:3.1.0'
+ testRuntime 'javax.annotation:jsr250-api:1.0'
+ testRuntime 'javax.ejb:ejb-api:3.0'
+ testRuntime 'javax.persistence:persistence-api:1.0.2'
+
+ provided(project(path: ':extensions/gemfire-modules', configuration: 'testOutput')) {
+ // Remove everything related to Tomcat 6.x
+ exclude group: 'org.apache.tomcat', module: 'catalina'
+ exclude group: 'org.apache.tomcat', module: 'catalina-ha'
+ exclude group: 'org.apache.tomcat', module: 'juli'
+ }
+ provided project(path: ':gemfire-junit', configuration: 'testOutput')
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/48552465/extensions/gemfire-modules-tomcat7/src/main/java/com/gemstone/gemfire/modules/session/catalina/Tomcat7DeltaSessionManager.java
----------------------------------------------------------------------
diff --git a/extensions/gemfire-modules-tomcat7/src/main/java/com/gemstone/gemfire/modules/session/catalina/Tomcat7DeltaSessionManager.java b/extensions/gemfire-modules-tomcat7/src/main/java/com/gemstone/gemfire/modules/session/catalina/Tomcat7DeltaSessionManager.java
new file mode 100644
index 0000000..d1f44bb
--- /dev/null
+++ b/extensions/gemfire-modules-tomcat7/src/main/java/com/gemstone/gemfire/modules/session/catalina/Tomcat7DeltaSessionManager.java
@@ -0,0 +1,112 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You 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.gemstone.gemfire.modules.session.catalina;
+
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.LifecycleState;
+
+import java.io.IOException;
+
+public class Tomcat7DeltaSessionManager extends DeltaSessionManager {
+
+ /**
+ * Prepare for the beginning of active use of the public methods of this component. This method should be called
+ * after <code>configure()</code>, and before any of the public methods of the component are utilized.
+ *
+ * @throws LifecycleException if this component detects a fatal error that prevents this component from being used
+ */
+ @Override
+ public void startInternal() throws LifecycleException {
+ super.startInternal();
+ if (getLogger().isDebugEnabled()) {
+ getLogger().debug(this + ": Starting");
+ }
+ if (this.started.get()) {
+ return;
+ }
+
+ this.lifecycle.fireLifecycleEvent(START_EVENT, null);
+
+ // Register our various valves
+ registerJvmRouteBinderValve();
+
+ if (isCommitValveEnabled()) {
+ registerCommitSessionValve();
+ }
+
+ // Initialize the appropriate session cache interface
+ initializeSessionCache();
+
+ try {
+ load();
+ } catch (ClassNotFoundException e) {
+ throw new LifecycleException("Exception starting manager", e);
+ } catch (IOException e) {
+ throw new LifecycleException("Exception starting manager", e);
+ }
+
+ // Create the timer and schedule tasks
+ scheduleTimerTasks();
+
+ this.started.set(true);
+ this.setState(LifecycleState.STARTING);
+ }
+
+ /**
+ * Gracefully terminate the active use of the public methods of this component. This method should be the last one
+ * called on a given instance of this component.
+ *
+ * @throws LifecycleException if this component detects a fatal error that needs to be reported
+ */
+ @Override
+ public void stopInternal() throws LifecycleException {
+ super.stopInternal();
+ if (getLogger().isDebugEnabled()) {
+ getLogger().debug(this + ": Stopping");
+ }
+
+ try {
+ unload();
+ } catch (IOException e) {
+ getLogger().error("Unable to unload sessions", e);
+ }
+
+ this.started.set(false);
+ this.lifecycle.fireLifecycleEvent(STOP_EVENT, null);
+
+ // StandardManager expires all Sessions here.
+ // All Sessions are not known by this Manager.
+
+ super.destroyInternal();
+
+ // Clear any sessions to be touched
+ getSessionsToTouch().clear();
+
+ // Cancel the timer
+ cancelTimer();
+
+ // Unregister the JVM route valve
+ unregisterJvmRouteBinderValve();
+
+ if (isCommitValveEnabled()) {
+ unregisterCommitSessionValve();
+ }
+
+ this.setState(LifecycleState.STOPPING);
+ }
+
+}