/**
* 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
*/
@Override
public void addValve(Valve valve) {
// Validate that we can add this Valve
if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);
// Start the new component if necessary
if (getState().isAvailable()) {
if (valve instanceof Lifecycle) {
try {
((Lifecycle) valve).start();
} catch (LifecycleException e) {
log.error("StandardPipeline.addValve: start: ", e);
}
}
}
// Add this Valve to the set associated with this Pipeline
if (first == null) {
first = valve;
valve.setNext(basic);
} else {
Valve current = first;
while (current != null) {
if (current.getNext() == basic) {
current.setNext(valve);
valve.setNext(basic);
break;
}
current = current.getNext();
}
}
container.fireContainerEvent(Container.ADD_VALVE_EVENT, valve);
}
/** 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);
}
}
/**
* 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
*/
@Override
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 (getState().isAvailable() && (oldBasic instanceof Lifecycle)) {
try {
((Lifecycle) oldBasic).stop();
} catch (LifecycleException e) {
log.error("StandardPipeline.setBasic: stop", e);
}
}
if (oldBasic instanceof Contained) {
try {
((Contained) oldBasic).setContainer(null);
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
}
}
}
// Start the new component if necessary
if (valve == null) return;
if (valve instanceof Contained) {
((Contained) valve).setContainer(this.container);
}
if (getState().isAvailable() && valve instanceof Lifecycle) {
try {
((Lifecycle) valve).start();
} catch (LifecycleException e) {
log.error("StandardPipeline.setBasic: start", e);
return;
}
}
// Update the pipeline
Valve current = first;
while (current != null) {
if (current.getNext() == oldBasic) {
current.setNext(valve);
break;
}
current = current.getNext();
}
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
*/
@Override
public void removeValve(Valve valve) {
Valve current;
if (first == valve) {
first = first.getNext();
current = null;
} else {
current = first;
}
while (current != null) {
if (current.getNext() == valve) {
current.setNext(valve.getNext());
break;
}
current = current.getNext();
}
if (first == basic) first = null;
if (valve instanceof Contained) ((Contained) valve).setContainer(null);
// Stop this valve if necessary
if (getState().isAvailable()) {
if (valve instanceof Lifecycle) {
try {
((Lifecycle) valve).stop();
} catch (LifecycleException e) {
log.error("StandardPipeline.removeValve: stop: ", e);
}
}
}
try {
((Lifecycle) valve).destroy();
} catch (LifecycleException e) {
log.error("StandardPipeline.removeValve: destroy: ", e);
}
container.fireContainerEvent(Container.REMOVE_VALVE_EVENT, valve);
}