Java 类org.apache.catalina.LifecycleException 实例源码

@Test
void mbeansAvailableAfterBinder() throws LifecycleException, InterruptedException {
    TomcatMetrics.monitor(registry, null);

    CountDownLatch latch = new CountDownLatch(1);
    registry.config().onMeterAdded(m -> {
        if(m.getId().getName().equals("tomcat.global.received"))
            latch.countDown();
    });

    Tomcat server = new Tomcat();
    try {
        StandardHost host = new StandardHost();
        host.setName("localhost");
        server.setHost(host);
        server.setPort(61000);
        server.start();

        assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();

        assertThat(registry.find("tomcat.global.received").functionCounter()).isNotNull();
    } finally {
        server.stop();
        server.destroy();
    }
}

/**
 * Stop this component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void stopInternal() throws LifecycleException {

    if (log.isDebugEnabled())
        log.debug(sm.getString("deltaManager.stopped", getName()));

    setState(LifecycleState.STOPPING);

    // Expire all active sessions
    if (log.isInfoEnabled()) log.info(sm.getString("deltaManager.expireSessions", getName()));
    Session sessions[] = findSessions();
    for (int i = 0; i < sessions.length; i++) {
        DeltaSession session = (DeltaSession) sessions[i];
        if (!session.isValid())
            continue;
        try {
            session.expire(true, isExpireSessionsOnShutdown());
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
        } 
    }

    // Require a new random number generator if we are restarted
    super.stopInternal();
}

/**
 * Invoked by tomcat on shutdown. The database connection is closed here.
 * 
 * @exception LifecycleException Can be thrown on lifecycle 
 * inconsistencies or on database errors (as a wrapped SQLException).
 */
public void stop() throws LifecycleException {

    if (!started)
        throw new LifecycleException
            (sm.getString("accessLogValve.notStarted"));
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    try {
        if (ps != null)
            ps.close();
        if (conn != null)
            conn.close();
    } catch (SQLException e) {
        throw new LifecycleException(e);    
    }

}

/** Destroy needs to clean up the context completely.
 * 
 * The problem is that undoing all the config in start() and restoring 
 * a 'fresh' state is impossible. After stop()/destroy()/init()/start()
 * we should have the same state as if a fresh start was done - i.e
 * read modified web.xml, etc. This can only be done by completely 
 * removing the context object and remapping a new one, or by cleaning
 * up everything.
 * 
 * XXX Should this be done in stop() ?
 * 
 */ 
@Override
protected void destroyInternal() throws LifecycleException {

    // If in state NEW when destroy is called, the object name will never
    // have been set so the notification can't be created
    if (getObjectName() != null) { 
        // Send j2ee.object.deleted notification 
        Notification notification = 
            new Notification("j2ee.object.deleted", this.getObjectName(), 
                             sequenceNumber.getAndIncrement());
        broadcaster.sendNotification(notification);
    }

    if (namingResources != null) {
        namingResources.destroy();
    }

    synchronized (instanceListenersLock) {
        instanceListeners = new String[0];
    }

    super.destroyInternal();
}

/**
 *
 * Prepare for active use of the public methods of this Component.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents it from being started
 */
public void start() throws LifecycleException {

    // Perform normal superclass initialization
    super.start();

    // Validate that we can open our connection - but let tomcat
    // startup in case the database is temporarily unavailable
    try {
        open();
    } catch (SQLException e) {
        containerLog.error(sm.getString("jdbcRealm.open"), e);
    }

}

@Override
protected void initInternal() throws LifecycleException {
    super.initInternal();

    // Kerberos configuration file location
    String krb5Conf = System.getProperty(Constants.KRB5_CONF_PROPERTY);
    if (krb5Conf == null) {
        // System property not set, use the Tomcat default
        File krb5ConfFile = new File(Bootstrap.getCatalinaBase(), Constants.DEFAULT_KRB5_CONF);
        System.setProperty(Constants.KRB5_CONF_PROPERTY, krb5ConfFile.getAbsolutePath());
    }

    // JAAS configuration file location
    String jaasConf = System.getProperty(Constants.JAAS_CONF_PROPERTY);
    if (jaasConf == null) {
        // System property not set, use the Tomcat default
        File jaasConfFile = new File(Bootstrap.getCatalinaBase(), Constants.DEFAULT_JAAS_CONF);
        System.setProperty(Constants.JAAS_CONF_PROPERTY, jaasConfFile.getAbsolutePath());
    }
}

/**
 * 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.  It should also send a LifecycleEvent
 * of type STOP_EVENT to any registered listeners.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that needs to be reported
 */
public void stop() throws LifecycleException {

    // Validate and update our current component state
    if (!started)
        throw new LifecycleException
            (sm.getString("standardServer.stop.notStarted"));

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    // Stop our defined Services
    for (int i = 0; i < services.length; i++) {
        if (services[i] instanceof Lifecycle)
            ((Lifecycle) services[i]).stop();
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);

}

/**
 * Create and return a new processor suitable for processing HTTP
 * requests and returning the corresponding responses.
 */
private HttpProcessor newProcessor() {

    //        if (debug >= 2)
    //            log("newProcessor: Creating new processor");
    HttpProcessor processor = new HttpProcessor(this, curProcessors++);
    if (processor instanceof Lifecycle) {
        try {
            ((Lifecycle) processor).start();
        } catch (LifecycleException e) {
            log("newProcessor", e);
            return (null);
        }
    }
    created.addElement(processor);
    return (processor);

}

@Test
public void testBug57425() throws LifecycleException, IOException {
    Tomcat tomcat = getTomcatInstance();
    Host host = tomcat.getHost();
    if (host instanceof StandardHost) {
        ((StandardHost) host).setContextClass(ReplicatedContext.class.getName());
    }

    File root = new File("test/webapp-3.0");
    Context context = tomcat.addWebapp(host, "", root.getAbsolutePath());

    Tomcat.addServlet(context, "test", new AccessContextServlet());
    context.addServletMapping("/access", "test");

    tomcat.start();

    ByteChunk result = getUrl("http://localhost:" + getPort() + "/access");

    Assert.assertEquals("OK", result.toString());

}

/**
 * Stop this component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void stopInternal() throws LifecycleException {

    super.stopInternal();

    // Close and release everything associated with our db.
    if (dbConnection != null) {
        try {
            dbConnection.commit();
        } catch (SQLException e) {
            // Ignore
        }
        close(dbConnection);
    }
}

/**
 * Start this component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException
 *                if this component detects a fatal error that prevents this
 *                component from being used
 */
@Override
protected synchronized void startInternal() throws LifecycleException {
    super.startInternal();
    try {
        CatalinaCluster catclust = (CatalinaCluster) this.getCluster();
        if (catclust != null) {
            ReplicatedMap<String, Object> map = new ReplicatedMap<String, Object>(this, catclust.getChannel(),
                    DEFAULT_REPL_TIMEOUT, getName(), getClassLoaders());
            map.setChannelSendOptions(mapSendOptions);
            ((ReplApplContext) this.context).setAttributeMap(map);
        }
    } catch (Exception x) {
        log.error("Unable to start ReplicatedContext", x);
        throw new LifecycleException("Failed to start ReplicatedContext", x);
    }
}

private void addChildInternal(Container child) {

        if (log.isDebugEnabled())
            log.debug("Add child " + child + " " + this);
        synchronized (children) {
            if (children.get(child.getName()) != null)
                throw new IllegalArgumentException("addChild:  Child name '" + child.getName() + "' is not unique");
            child.setParent(this); // May throw IAE
            children.put(child.getName(), child);
        }

        // Start child
        // Don't do this inside sync block - start can be a slow process and
        // locking the children object can cause problems elsewhere
        try {
            if ((getState().isAvailable() || LifecycleState.STARTING_PREP.equals(getState())) && startChildren) {
                child.start();
            }
        } catch (LifecycleException e) {
            System.out.println("log:" + log);
            log.error("ContainerBase.addChild: start: ", e);
            throw new IllegalStateException("ContainerBase.addChild: start: " + e);
        } finally {
            fireContainerEvent(ADD_CHILD_EVENT, child);
        }
    }

/**
 * Start an existing web application, attached to the specified context
 * path.  Only starts a web application if it is not running.
 *
 * @param contextPath The context path of the application to be started
 *
 * @exception IllegalArgumentException if the specified context path
 *  is malformed (it must be "" or start with a slash)
 * @exception IllegalArgumentException if the specified context path does
 *  not identify a currently installed web application
 * @exception IOException if an input/output error occurs during
 *  startup
 */
public void start(String contextPath) throws IOException {
    // Validate the format and state of our arguments
    if (contextPath == null)
        throw new IllegalArgumentException
            (sm.getString("standardHost.pathRequired"));
    if (!contextPath.equals("") && !contextPath.startsWith("/"))
        throw new IllegalArgumentException
            (sm.getString("standardHost.pathFormat", contextPath));
    Context context = findDeployedApp(contextPath);
    if (context == null)
        throw new IllegalArgumentException
            (sm.getString("standardHost.pathMissing", contextPath));
    host.log("standardHost.start " + contextPath);
    try {
        ((Lifecycle) context).start();
    } catch (LifecycleException e) {
        host.log("standardHost.start " + contextPath + ": ", e);
        throw new IllegalStateException
            ("standardHost.start " + contextPath + ": " + e);
    }
}

/**
 * Prepare for the beginning of active use of the public methods of this
 * component.  This method should be called before any of the public
 * methods of this component are utilized.  It should also send a
 * LifecycleEvent of type START_EVENT to any registered listeners.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
public void start() throws LifecycleException {

    // Validate and update our current component state
    if (started) {
        if(log.isInfoEnabled())
            log.info(sm.getString("realmBase.alreadyStarted"));
        return;
    }
    if( !initialized ) {
        init();
    }
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    started = true;

    // Create a MessageDigest instance for credentials, if desired
    if (digest != null) {
        try {
            md = MessageDigest.getInstance(digest);
        } catch (NoSuchAlgorithmException e) {
            throw new LifecycleException
                (sm.getString("realmBase.algorithm", digest), e);
        }
    }

}

/**
 * Stop {@link Valve}s) in this pipeline and implement the requirements
 * of {@link LifecycleBase#stopInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void stopInternal() throws LifecycleException {

    setState(LifecycleState.STOPPING);

    // Stop the Valves in our pipeline (including the basic), if any
    Valve current = first;
    if (current == null) {
        current = basic;
    }
    while (current != null) {
        if (current instanceof Lifecycle)
            ((Lifecycle) current).stop();
        current = current.getNext();
    }
}

/**
 * Prepare for the beginning of active use of the public methods of this
 * component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected void startInternal() throws LifecycleException {

    // Check to see if the connection to the directory can be opened
    try {
        open();
    } catch (NamingException e) {
        // A failure here is not fatal as the directory may be unavailable
        // now but available later. Unavailability of the directory is not
        // fatal once the Realm has started so there is no reason for it to
        // be fatal when the Realm starts.
        containerLog.error(sm.getString("jndiRealm.open"), e);
    }

    super.startInternal();
}

/**
 * Add a new Service to the set of defined Services.
 *
 * @param service The Service to be added
 */
@Override
public void addService(Service service) {

    service.setServer(this);

    synchronized (servicesLock) {
        Service results[] = new Service[services.length + 1];
        System.arraycopy(services, 0, results, 0, services.length);
        results[services.length] = service;
        services = results;

        if (getState().isAvailable()) {
            try {
                service.start();
            } catch (LifecycleException e) {
                // Ignore
            }
        }

        // Report this property change to interested listeners
        support.firePropertyChange("service", null, service);
    }

}

@Override
protected void destroyInternal() throws LifecycleException {
    // Destroy our defined Connectors
    synchronized (connectorsLock) {
        for (Connector connector : connectors) {
            try {
                connector.destroy();
            } catch (Exception e) {
                log.error(sm.getString("standardService.connector.destroyFailed", connector), e);
            }
        }
    }

    // Destroy any Executors
    for (Executor executor : findExecutors()) {
        executor.destroy();
    }

    if (container != null) {
        container.destroy();
    }

    super.destroyInternal();
}

/**
 * Stop this component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void stopInternal() throws LifecycleException {

    super.stopInternal();

    cluster = null;
    numberOfSessions = 0;
    if (log.isInfoEnabled())
        log.info(sm.getString("jvmRoute.valve.stopped"));

}

/**
 * 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.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that needs to be reported
 */
public void stop() throws LifecycleException {

    // Validate and update our current component state
    if (!started)
        throw new LifecycleException
            (sm.getString("authenticator.notStarted"));
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    sso = null;

}

private void addChildInternal(Container child) {

        if( log.isDebugEnabled() )
            log.debug("Add child " + child + " " + this);
        synchronized(children) {
            if (children.get(child.getName()) != null)
                throw new IllegalArgumentException("addChild:  Child name '" +
                                                   child.getName() +
                                                   "' is not unique");
            child.setParent(this);  // May throw IAE
            children.put(child.getName(), child);

            // Start child
            if (started && startChildren && (child instanceof Lifecycle)) {
                boolean success = false;
                try {
                    ((Lifecycle) child).start();
                    success = true;
                } catch (LifecycleException e) {
                    log.error("ContainerBase.addChild: start: ", e);
                    throw new IllegalStateException
                        ("ContainerBase.addChild: start: " + e);
                } finally {
                    if (!success) {
                        children.remove(child.getName());
                    }
                }
            }

            fireContainerEvent(ADD_CHILD_EVENT, child);
        }

    }

@Override
public void stopInternal() throws LifecycleException {
    setState(LifecycleState.STOPPING);

    Engine engine = (Engine) connector.getService().getContainer();
    removeListeners(engine);
}

/**
 * Prepare for active use of the public methods of this Component.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents it from being started
 */
public void start() throws LifecycleException {

    // Validate that we can open our connection
    try {
        open();
    } catch (NamingException e) {
        throw new LifecycleException(sm.getString("jndiRealm.open"), e);
    }

    // Perform normal superclass initialization
    super.start();

}

/**
 * Stop this component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void stopInternal() throws LifecycleException {

    setState(LifecycleState.STOPPING);

    if (container instanceof Context) {
        container.removeLifecycleListener(this);
    }
}

/**
 * Start this component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void startInternal() throws LifecycleException {

    super.startInternal();

    // Load unloaded sessions, if any
    try {
        if (cluster == null) {
            log.error(sm.getString("deltaManager.noCluster", getName()));
            return;
        } else {
            if (log.isInfoEnabled()) {
                String type = "unknown" ;
                if( cluster.getContainer() instanceof Host){
                    type = "Host" ;
                } else if( cluster.getContainer() instanceof Engine){
                    type = "Engine" ;
                }
                log.info(sm.getString("deltaManager.registerCluster", getName(), type, cluster.getClusterName()));
            }
        }
        if (log.isInfoEnabled()) log.info(sm.getString("deltaManager.startClustering", getName()));

        getAllClusterSessions();

    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        log.error(sm.getString("deltaManager.managerLoad"), t);
    }

    setState(LifecycleState.STARTING);
}

/**
 * Add this Mover as Cluster Listener ( receiver)
 * 
 * @throws LifecycleException
 */
public void start() throws LifecycleException {
    if (started)
        return;
    getCluster().addClusterListener(this);
    started = true;
    if (log.isInfoEnabled())
        log.info(sm.getString("jvmRoute.clusterListener.started"));
}

/**
 * Invoke a pre-startup initialization. This is used to allow connectors
 * to bind to restricted ports under Unix operating environments.
 */
@Override
protected void initInternal() throws LifecycleException {

    super.initInternal();

    if (container != null) {
        container.init();
    }

    // Initialize any Executors
    for (Executor executor : findExecutors()) {
        if (executor instanceof LifecycleMBeanBase) {
            ((LifecycleMBeanBase) executor).setDomain(getDomain());
        }
        executor.init();  // StandardThreadExecutor#initInternal
    }

    // Initialize our defined Connectors
    synchronized (connectorsLock) {
        for (Connector connector : connectors) {
            try {
                connector.init();
            } catch (Exception e) {
                String message = sm.getString(
                        "standardService.connector.initFailed", connector);
                log.error(message, e);

                if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
                    throw new LifecycleException(message);
            }
        }
    }
}

/**
 * Start this component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException
 *                if this component detects a fatal error that prevents this
 *                component from being used
 */
@Override
protected synchronized void startInternal() throws LifecycleException {

    // Log our server identification information
    if (log.isInfoEnabled())
        log.info("Starting Servlet Engine: " + ServerInfo.getServerInfo());

    // Standard container startup
    super.startInternal();
}

/**
 * Start this component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected synchronized void startInternal() throws LifecycleException {

    // Log our server identification information
    if(log.isInfoEnabled())
        log.info( "Starting Servlet Engine: " + ServerInfo.getServerInfo());

    // Standard container startup
    super.startInternal();
}

@Override
public void stop() throws LifecycleException {
    started = false;
    getCluster().removeClusterListener(this);
    count = 0;
    if (watcher != null) {
        watcher.clear();
        watcher = null;

    }
    if (log.isInfoEnabled())
        log.info(sm.getString("farmWarDeployer.stopped"));
}

@Override
protected void destroyInternal() throws LifecycleException {
    if (onameClusterDeployer != null) {
        unregister(onameClusterDeployer);
        onameClusterDeployer = null;
    }
    super.destroyInternal();
}

/**
 * Remove the specified Service from the set associated from this
 * Server.
 *
 * @param service The Service to be removed
 */
public void removeService(Service service) {

    synchronized (services) {
        int j = -1;
        for (int i = 0; i < services.length; i++) {
            if (service == services[i]) {
                j = i;
                break;
            }
        }
        if (j < 0)
            return;
        if (services[j] instanceof Lifecycle) {
            try {
                ((Lifecycle) services[j]).stop();
            } catch (LifecycleException e) {
                ;
            }
        }
        int k = 0;
        Service results[] = new Service[services.length - 1];
        for (int i = 0; i < services.length; i++) {
            if (i != j)
                results[k++] = services[i];
        }
        services = results;

        // Report this property change to interested listeners
        support.firePropertyChange("service", service, null);
    }

}

/**
 * Gracefully shut down active use of the public methods of this Component.
 *
 * @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
            (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);

}

@Override
protected void startInternal() throws LifecycleException {
    // Ensure SecureRandom has been initialised
    generateSessionId();

    setState(LifecycleState.STARTING);
}

@Override
public synchronized void close() throws IOException {
  if (tomcat != null) {
    try {
      tomcat.stop();
      tomcat.destroy();
    } catch (LifecycleException le) {
      log.warn("Unexpected error while stopping", le);
    } finally {
      tomcat = null;
    }
    IOUtils.deleteRecursively(noSuchBaseDir);
  }
}

/**
 * Stop the background thread we will use for request processing.
 *
 * @exception LifecycleException if a fatal shutdown error occurs
 */
public void stop() throws LifecycleException {

    if (!started)
        throw new LifecycleException
            (sm.getString("httpProcessor.notStarted"));
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    threadStop();

}

/**
 * Invoked by tomcat on shutdown. The database connection is closed here.
 * 
 * @exception LifecycleException Can be thrown on lifecycle 
 * inconsistencies or on database errors (as a wrapped SQLException).
 */
public void stop() throws LifecycleException {

    if (!started)
        throw new LifecycleException
            (sm.getString("accessLogValve.notStarted"));
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    close() ;

}

public void start() throws LifecycleException {
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
    TaskQueue taskqueue = new TaskQueue();
    TaskThreadFactory tf = new TaskThreadFactory(namePrefix);
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,taskqueue, tf);
    taskqueue.setParent( (ThreadPoolExecutor) executor);
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}

/**
 * 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.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
public void start() throws LifecycleException {

    // Validate and update our current component state
    if (started)
        throw new LifecycleException
            (sm.getString("authenticator.alreadyStarted"));
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    started = true;

    if (debug >= 1)
        log("Started");

}

@Override
protected void initInternal() throws LifecycleException {
    super.initInternal();
    if (!allowValid || !denyValid) {
        throw new LifecycleException(sm.getString("requestFilterValve.configInvalid"));
    }
}