/**
* 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;
}
}
/**
* 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);
*/
}
}
/**
* Add a new Valve to the end of the pipeline associated with this Container. Prior to adding the
* Valve, the Valve's <code>setContainer()</code> method 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 added
* @exception IllegalArgumentException if this Container refused to accept the specified Valve
* @exception IllegalArgumentException if the specified Valve refuses to be associated with this
* Container
* @exception IllegalStateException if the specified Valve is already associated with a different
* Container
*/
public void addValve(GlassFishValve valve) {
if (firstTcValve != null) {
// Wrap GlassFish-style valve inside Tomcat-style valve
addValve(new TomcatValveAdapter(valve));
return;
}
// Validate that we can add this Valve
if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);
// Start the new component if necessary
if (started) {
if (valve instanceof Lifecycle) {
try {
((Lifecycle) valve).start();
} catch (LifecycleException e) {
log.log(Level.SEVERE, ADD_VALVE_EXCEPTION, e);
}
}
/**
* CR 6411114 (MBean registration moved to ValveBase.start()) // Register the newly added
* valve registerValve(valve);
*/
}
// Add this Valve to the set associated with this Pipeline
GlassFishValve results[] = new GlassFishValve[valves.length + 1];
System.arraycopy(valves, 0, results, 0, valves.length);
results[valves.length] = valve;
valves = results;
}
/**
* 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);
}
/** Add Tomcat-style valve. */
public synchronized void addValve(Valve valve) {
/*
* Check if this is a GlassFish-style valve that was compiled
* against the old org.apache.catalina.Valve interface (from
* GlassFish releases prior to V3), which has since been renamed
* to org.glassfish.web.valve.GlassFishValve (in V3)
*/
if (isGlassFishValve(valve)) {
try {
addValve(new GlassFishValveAdapter(valve));
} catch (Exception e) {
String msg = MessageFormat.format(rb.getString(ADD_TOMCAT_STYLE_VALVE_EXCEPTION), valve);
log.log(Level.SEVERE, msg, e);
}
return;
}
if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);
// Start the new Valve if necessary
if (started) {
if (valve instanceof Lifecycle) {
try {
((Lifecycle) valve).start();
} catch (LifecycleException e) {
log.log(Level.SEVERE, ADD_VALVE_EXCEPTION, e);
}
}
}
if (firstTcValve == null) {
firstTcValve = lastTcValve = valve;
} else {
lastTcValve.setNext(valve);
lastTcValve = valve;
}
if (basic != null) {
valve.setNext((Valve) basic);
}
}
