/**
* Remove the specified Valve from the pipeline associated with this Container, if it is found;
* otherwise, do nothing. If the Valve is found and removed, the Valve's <code>setContainer(null)
* </code> method will be called if it implements <code>Contained</code>.
*
* @param valve Valve to be removed
*/
public void removeValve(GlassFishValve valve) {
// Locate this Valve in our list
int j = -1;
for (int i = 0; i < valves.length; i++) {
if (valve == valves[i]) {
j = i;
break;
}
}
if (j < 0) return;
// Remove this valve from our list
GlassFishValve results[] = new GlassFishValve[valves.length - 1];
int n = 0;
for (int i = 0; i < valves.length; i++) {
if (i == j) continue;
results[n++] = valves[i];
}
valves = results;
try {
if (valve instanceof Contained) ((Contained) valve).setContainer(null);
} catch (Throwable t) {;
}
// Stop this valve if necessary
if (started) {
if (valve instanceof ValveBase) {
if (((ValveBase) valve).isStarted()) {
try {
((Lifecycle) valve).stop();
} catch (LifecycleException e) {
log.log(Level.SEVERE, REMOVE_VALVE_EXCEPTION, e);
}
}
} else if (valve instanceof Lifecycle) {
try {
((Lifecycle) valve).stop();
} catch (LifecycleException e) {
log.log(Level.SEVERE, REMOVE_VALVE_EXCEPTION, e);
}
}
/**
* CR 6411114 (MBean deregistration moved to ValveBase.stop()) // Unregister the removed valve
* unregisterValve(valve);
*/
}
}
@Override
public void stop() throws ServletException {
ThreadSetupAction.Handle handle = deployment.getThreadSetupAction().setup(null);
try {
try {
for (Lifecycle object : deployment.getLifecycleObjects()) {
object.stop();
}
} finally {
if (executor != null) {
executor.release();
}
if (asyncExecutor != null) {
asyncExecutor.release();
}
executor = null;
asyncExecutor = null;
}
} finally {
handle.tearDown();
if (executor != null) {
executor.release();
}
if (asyncExecutor != null) {
asyncExecutor.release();
}
executor = null;
asyncExecutor = null;
}
deployment.getDeploymentInfo().getSessionManager().stop();
state = State.DEPLOYED;
}
/**
* Gracefully shut down active use of the public methods of this Component.
*
* @exception IllegalStateException if this component has not been started
* @exception LifecycleException if this component detects a fatal error that needs to be reported
*/
public synchronized void stop() throws LifecycleException {
// Validate and update our current component state
if (!started) throw new LifecycleException(rb.getString(PIPLINE_NOT_STARTED));
started = false;
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
// Stop the Valves in our pipeline (including the basic), if any
if ((basic != null) && (basic instanceof Lifecycle)) ((Lifecycle) basic).stop();
/**
* CR 6411114 (MBean deregistration moved to ValveBase.stop()) if( basic!=null ) {
* unregisterValve(basic); }
*/
for (int i = 0; i < valves.length; i++) {
if (valves[i] instanceof Lifecycle) ((Lifecycle) valves[i]).stop();
/** CR 6411114 (MBean deregistration moved to ValveBase.stop()) unregisterValve(valves[i]); */
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
}
/**
* Set the Valve instance that has been distinguished as the basic Valve for this Pipeline (if
* any). Prior to setting the basic Valve, the Valve's <code>setContainer()</code> will be called,
* if it implements <code>Contained</code>, with the owning Container as an argument. The method
* may throw an <code>IllegalArgumentException</code> if this Valve chooses not to be associated
* with this Container, or <code>IllegalStateException</code> if it is already associated with a
* different Container.
*
* @param valve Valve to be distinguished as the basic Valve
*/
public void setBasic(GlassFishValve valve) {
// Change components if necessary
GlassFishValve oldBasic = null;
synchronized (this) {
oldBasic = this.basic;
}
if (oldBasic == valve) {
return;
}
// Stop the old component if necessary
if (oldBasic != null) {
synchronized (this) {
if (started && (oldBasic instanceof Lifecycle)) {
try {
((Lifecycle) oldBasic).stop();
} catch (LifecycleException e) {
log.log(Level.SEVERE, SET_BASIC_STOP_EXCEPTION, e);
}
}
}
if (oldBasic instanceof Contained) {
try {
((Contained) oldBasic).setContainer(null);
} catch (Throwable t) {
// Ignore
}
}
}
// Start the new component if necessary
if (valve == null) {
return;
}
if (valve instanceof Contained) {
((Contained) valve).setContainer(this.container);
}
/** CR 6411114 if (valve instanceof Lifecycle) { */
// START CR 6411114
// Start the valve if the pipeline has already been started
if (started && (valve instanceof Lifecycle)) {
// END CR 6411114
try {
((Lifecycle) valve).start();
} catch (LifecycleException e) {
log.log(Level.SEVERE, SET_BASIC_START_EXCEPTION, e);
return;
}
}
synchronized (this) {
this.basic = valve;
}
}
@Override
public void stop() throws Exception {
for (Lifecycle lifecycle : reverseLifecycles()) {
try {
lifecycle.stop();
} catch (Throwable t) {
LOG.error("Failed to stop Lifecycle: " + lifecycle.getClass().getName(), t);
}
}
super.stop();
}
/**
* Gracefully shut down active use of the public methods of this Component.
*
* @throws LifecycleException if this component detects a fatal error that needs to be reported
*/
public synchronized void stop() throws LifecycleException {
// Validate and update our current component state
if (!started) throw new LifecycleException(sm.getString("standardPipeline.notStarted"));
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
started = false;
// Stop the Valves in our pipeline (including the basic), if any
if ((basic != null) && (basic instanceof Lifecycle)) ((Lifecycle) basic).stop();
for (int i = 0; i < valves.length; i++) {
if (valves[i] instanceof Lifecycle) ((Lifecycle) valves[i]).stop();
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
}
/**
* Set the Valve instance that has been distinguished as the basic Valve for this Pipeline (if
* any). Prioer to setting the basic Valve, the Valve's <code>setContainer()</code> will be
* called, if it implements <code>Contained</code>, with the owning Container as an argument. The
* method may throw an <code>IllegalArgumentException</code> if this Valve chooses not to be
* associated with this Container, or <code>IllegalStateException</code> if it is already
* associated with a different Container.
*
* @param valve Valve to be distinguished as the basic Valve
*/
public void setBasic(Valve valve) {
// Change components if necessary
Valve oldBasic = this.basic;
if (oldBasic == valve) return;
// Stop the old component if necessary
if (oldBasic != null) {
if (started && (oldBasic instanceof Lifecycle)) {
try {
((Lifecycle) oldBasic).stop();
} catch (LifecycleException e) {
log("StandardPipeline.setBasic: stop", e);
}
}
if (oldBasic instanceof Contained) {
try {
((Contained) oldBasic).setContainer(null);
} catch (Throwable t) {;
}
}
}
// Start the new component if necessary
if (valve == null) return;
if (valve instanceof Contained) {
((Contained) valve).setContainer(this.container);
}
if (valve instanceof Lifecycle) {
try {
((Lifecycle) valve).start();
} catch (LifecycleException e) {
log("StandardPipeline.setBasic: start", e);
return;
}
}
this.basic = valve;
}
/**
* Remove the specified Valve from the pipeline associated with this Container, if it is found;
* otherwise, do nothing. If the Valve is found and removed, the Valve's <code>setContainer(null)
* </code> method will be called if it implements <code>Contained</code>.
*
* @param valve Valve to be removed
*/
public void removeValve(Valve valve) {
synchronized (valves) {
// Locate this Valve in our list
int j = -1;
for (int i = 0; i < valves.length; i++) {
if (valve == valves[i]) {
j = i;
break;
}
}
if (j < 0) return;
// Remove this valve from our list
Valve results[] = new Valve[valves.length - 1];
int n = 0;
for (int i = 0; i < valves.length; i++) {
if (i == j) continue;
results[n++] = valves[i];
}
valves = results;
try {
if (valve instanceof Contained) ((Contained) valve).setContainer(null);
} catch (Throwable t) {;
}
}
// Stop this valve if necessary
if (started && (valve instanceof Lifecycle)) {
try {
((Lifecycle) valve).stop();
} catch (LifecycleException e) {
log("StandardPipeline.removeValve: stop: ", e);
}
}
}
private void testFailover(Lifecycle lifecycle, URL baseURL1, URL baseURL2) throws Exception {
HttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient();
URI uri1 = SimpleServlet.createURI(baseURL1);
URI uri2 = SimpleServlet.createURI(baseURL2);
this.establishTopology(baseURL1, NODES);
try {
HttpResponse response = client.execute(new HttpGet(uri1));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
1, Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
Assert.assertEquals(NODE_1, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
} finally {
HttpClientUtils.closeQuietly(response);
}
// Let's do this twice to have more debug info if failover is slow.
response = client.execute(new HttpGet(uri1));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
2, Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_1, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
// Gracefully undeploy from/shutdown the 1st container.
lifecycle.stop(NODE_1);
this.establishTopology(baseURL2, NODE_2);
// Now check on the 2nd server
response = client.execute(new HttpGet(uri2));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
"Session failed to replicate after container 1 was shutdown.",
3,
Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
Assert.assertEquals(NODE_2, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
} finally {
HttpClientUtils.closeQuietly(response);
}
// Let's do one more check.
response = client.execute(new HttpGet(uri2));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
4, Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_2, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
lifecycle.start(NODE_1);
this.establishTopology(baseURL2, NODES);
response = client.execute(new HttpGet(uri2));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
"Session failed to replicate after container 1 was brough up.",
5,
Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_1, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
// The previous and next requests intentially hit the non-owning node
this.nonOwnerTask.run();
// Let's do this twice to have more debug info if failover is slow.
response = client.execute(new HttpGet(uri2));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
6, Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_1, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
// Until graceful undeploy is supported, we need to wait for replication to complete before
// undeploy (WFLY-6769).
if (lifecycle instanceof RedeployLifecycle) {
Thread.sleep(GRACE_TIME_TO_REPLICATE);
}
// Gracefully undeploy from/shutdown the 1st container.
lifecycle.stop(NODE_2);
this.establishTopology(baseURL1, NODE_1);
// Now check on the 2nd server
response = client.execute(new HttpGet(uri1));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
"Session failed to replicate after container 1 was shutdown.",
7,
Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_1, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
// Let's do one more check.
response = client.execute(new HttpGet(uri1));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
8, Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_1, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
lifecycle.start(NODE_2);
this.establishTopology(baseURL1, NODES);
response = client.execute(new HttpGet(uri1));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
"Session failed to replicate after container 1 was brought up.",
9,
Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_2, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
// Let's do this twice to have more debug info if failover is slow.
response = client.execute(new HttpGet(uri1));
try {
Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
Assert.assertEquals(
10, Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
Map.Entry<String, String> entry = parseSessionRoute(response);
if (entry != null) {
Assert.assertEquals(NODE_2, entry.getValue());
Assert.assertEquals(
entry.getKey(), response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
}
} finally {
HttpClientUtils.closeQuietly(response);
}
} finally {
HttpClientUtils.closeQuietly(client);
}
}
public static void main(String[] args) {
System.setProperty("catalina.base", System.getProperty("user.dir"));
Connector connector = new HttpConnector();
Wrapper wrapper1 = new StandardWrapper();
wrapper1.setName("Primitive");
wrapper1.setServletClass("PrimitiveServlet");
Wrapper wrapper2 = new StandardWrapper();
wrapper2.setName("Modern");
wrapper2.setServletClass("ModernServlet");
Context context = new StandardContext();
// StandardContext's start method adds a default mapper
context.setPath("/app1");
context.setDocBase("app1");
context.addChild(wrapper1);
context.addChild(wrapper2);
LifecycleListener listener = new SimpleContextConfig();
((Lifecycle) context).addLifecycleListener(listener);
Host host = new StandardHost();
host.addChild(context);
host.setName("localhost");
host.setAppBase("webapps");
Loader loader = new WebappLoader();
context.setLoader(loader);
// context.addServletMapping(pattern, name);
context.addServletMapping("/Primitive", "Primitive");
context.addServletMapping("/Modern", "Modern");
Engine engine = new StandardEngine();
engine.addChild(host);
engine.setDefaultHost("localhost");
Service service = new StandardService();
service.setName("Stand-alone Service");
Server server = new StandardServer();
server.addService(service);
service.addConnector(connector);
// StandardService class's setContainer will call all its connector's setContainer method
service.setContainer(engine);
// Start the new server
if (server instanceof Lifecycle) {
try {
server.initialize();
((Lifecycle) server).start();
server.await();
// the program waits until the await method returns,
// i.e. until a shutdown command is received.
} catch (LifecycleException e) {
e.printStackTrace(System.out);
}
}
// Shut down the server
if (server instanceof Lifecycle) {
try {
((Lifecycle) server).stop();
} catch (LifecycleException e) {
e.printStackTrace(System.out);
}
}
}
