/** * 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); } } }