org.apache.catalina.Server Java Examples

/**
 * Register StoreRegistry after Start the complete Server.
 *
 * @see org.apache.catalina.LifecycleListener#lifecycleEvent(org.apache.catalina.LifecycleEvent)
 */
@Override
public void lifecycleEvent(LifecycleEvent event) {
    if (Lifecycle.AFTER_START_EVENT.equals(event.getType())) {
        if (event.getSource() instanceof Server) {
            createMBean((Server) event.getSource());
        } else {
            log.warn(sm.getString("storeConfigListener.notServer"));
        }
    } else if (Lifecycle.AFTER_STOP_EVENT.equals(event.getType())) {
        if (oname != null) {
            registry.unregisterComponent(oname);
            oname = null;
        }
    }
 }
 

/**
 * Creates a new StandardService and StandardEngine.
 *
 * @param domain       Domain name for the container instance
 * @param defaultHost  Name of the default host to be used in the Engine
 * @param baseDir      Base directory value for Engine 
 *
 * @exception Exception if an MBean cannot be created or registered
 */
public String createStandardServiceEngine(String domain,
        String defaultHost, String baseDir) throws Exception{

    if (!(container instanceof Server)) {
        throw new Exception("Container not Server");
    }
    
    StandardEngine engine = new StandardEngine();
    engine.setDomain(domain);
    engine.setName(domain);
    engine.setDefaultHost(defaultHost);
    engine.setBaseDir(baseDir);

    Service service = new StandardService();
    service.setContainer(engine);
    service.setName(domain);
    
    ((Server) container).addService(service);
    
    return engine.getObjectName().toString();
}
 

/**
 * Return the Server object that is the ultimate parent for the container
 * with which this Realm is associated. If the server cannot be found (eg
 * because the container hierarchy is not complete), <code>null</code> is
 * returned.
 */
protected Server getServer() {
    Container c = container;
    if (c instanceof Context) {
        c = c.getParent();
    }
    if (c instanceof Host) {
        c = c.getParent();
    }
    if (c instanceof Engine) {
        Service s = ((Engine)c).getService();
        if (s != null) {
            return s.getServer();
        }
    }
    return null;
}
 

/**
 * Return the Server object that is the ultimate parent for the container
 * with which this Realm is associated. If the server cannot be found (eg
 * because the container hierarchy is not complete), <code>null</code> is
 * returned.
 */
protected Server getServer() {
    Container c = container;
    if (c instanceof Context) {
        c = c.getParent();
    }
    if (c instanceof Host) {
        c = c.getParent();
    }
    if (c instanceof Engine) {
        Service s = ((Engine)c).getService();
        if (s != null) {
            return s.getServer();
        }
    }
    return null;
}
 

/**
 * Write the configuration information for this entire <code>Server</code>
 * out to the server.xml configuration file.
 *
 * @param aServer Server instance
 * @return <code>true</code> if the store operation was successful
 */
@Override
public synchronized boolean store(Server aServer) {
    StoreFileMover mover = new StoreFileMover(System
            .getProperty("catalina.base"), getServerFilename(),
            getRegistry().getEncoding());
    // Open an output writer for the new configuration file
    try {
        try (PrintWriter writer = mover.getWriter()) {
            store(writer, -2, aServer);
        }
        mover.move();
        return true;
    } catch (Exception e) {
        log.error(sm.getString("config.storeServerError"), e);
    }
    return false;
}
 

private static Server createServer(final String serverXml) {
    final Catalina catalina = new Catalina() {
        // skip few init we don't need *here*
        @Override
        protected void initDirs() {
            // no-op
        }

        @Override
        protected void initStreams() {
            // no-op
        }

        @Override
        protected void initNaming() {
            // no-op
        }
    };
    catalina.setConfigFile(serverXml);
    catalina.load();
    return catalina.getServer();
}
 

/**
 * Creates a new StandardService and StandardEngine.
 *
 * @param domain       Domain name for the container instance
 * @param defaultHost  Name of the default host to be used in the Engine
 * @param baseDir      Base directory value for Engine 
 *
 * @exception Exception if an MBean cannot be created or registered
 */
public String createStandardServiceEngine(String domain,
        String defaultHost, String baseDir) throws Exception{

    if (!(container instanceof Server)) {
        throw new Exception("Container not Server");
    }
    
    StandardEngine engine = new StandardEngine();
    engine.setDomain(domain);
    engine.setName(domain);
    engine.setDefaultHost(defaultHost);
    engine.setBaseDir(baseDir);

    Service service = new StandardService();
    service.setContainer(engine);
    service.setName(domain);
    
    ((Server) container).addService(service);
    
    return engine.getObjectName().toString();
}
 

/**
 * Return the Server object that is the ultimate parent for the container
 * with which this Realm is associated. If the server cannot be found (eg
 * because the container hierarchy is not complete), <code>null</code> is
 * returned.
 * @return the Server associated with the realm
 */
protected Server getServer() {
    Container c = container;
    if (c instanceof Context) {
        c = c.getParent();
    }
    if (c instanceof Host) {
        c = c.getParent();
    }
    if (c instanceof Engine) {
        Service s = ((Engine)c).getService();
        if (s != null) {
            return s.getServer();
        }
    }
    return null;
}
 

private Server getServer() {
    Container c = context;
    while (c != null && !(c instanceof Engine)) {
        c = c.getParent();
    }

    if (c == null) {
        return null;
    }

    Service s = ((Engine)c).getService();

    if (s == null) {
        return null;
    }

    return s.getServer();
}
 

private static Server createServer(final String serverXml) {
    final Catalina catalina = new Catalina() {
        // skip few init we don't need *here*
        @Override
        protected void initDirs() {
            // no-op
        }

        @Override
        protected void initStreams() {
            // no-op
        }

        @Override
        protected void initNaming() {
            // no-op
        }
    };
    catalina.setConfigFile(serverXml);
    catalina.load();
    return catalina.getServer();
}
 

/**
 * Creates a new StandardService and StandardEngine.
 *
 * @param domain       Domain name for the container instance
 * @param defaultHost  Name of the default host to be used in the Engine
 * @param baseDir      Base directory value for Engine
 * @return the object name of the created service
 *
 * @exception Exception if an MBean cannot be created or registered
 */
public String createStandardServiceEngine(String domain,
        String defaultHost, String baseDir) throws Exception{

    if (!(container instanceof Server)) {
        throw new Exception("Container not Server");
    }

    StandardEngine engine = new StandardEngine();
    engine.setDomain(domain);
    engine.setName(domain);
    engine.setDefaultHost(defaultHost);

    Service service = new StandardService();
    service.setContainer(engine);
    service.setName(domain);

    ((Server) container).addService(service);

    return engine.getObjectName().toString();
}
 

private Server getServer() {
    Container c = context;
    while (c != null && !(c instanceof Engine)) {
        c = c.getParent();
    }

    if (c == null) {
        return null;
    }

    Service s = ((Engine)c).getService();

    if (s == null) {
        return null;
    }

    return s.getServer();
}
 

/**
 * Process a "destroy" event for this Context.
 */
protected synchronized void destroy() {
    // Called from StandardContext.destroy()
    if (log.isDebugEnabled()) {
        log.debug(sm.getString("contextConfig.destroy"));
    }

    // Skip clearing the work directory if Tomcat is being shutdown
    Server s = getServer();
    if (s != null && !s.getState().isAvailable()) {
        return;
    }

    // Changed to getWorkPath per Bugzilla 35819.
    if (context instanceof StandardContext) {
        String workDir = ((StandardContext) context).getWorkPath();
        if (workDir != null) {
            ExpandWar.delete(new File(workDir));
        }
    }
}
 

/**
 * Process a "destroy" event for this Context.
 */
protected synchronized void destroy() {
    // Called from StandardContext.destroy()
    if (log.isDebugEnabled())
        log.debug(sm.getString("contextConfig.destroy"));

    // Skip clearing the work directory if Tomcat is being shutdown
    Server s = getServer();
    if (s != null && !s.getState().isAvailable()) {
        return;
    }

    // Changed to getWorkPath per Bugzilla 35819.
    if (context instanceof StandardContext) {
        String workDir = ((StandardContext) context).getWorkPath();
        if (workDir != null) {
            ExpandWar.delete(new File(workDir));
        }
    }
}
 

/**
 * Blocks and waits until the server shuts down.
 */
public void await() {
  Server server;
  synchronized (this) {
    server = tomcat.getServer();
  }
  server.await(); // Can't do this with lock held
}
 

@Override
public synchronized void close() {
    if (closed) {
        return;
    }
    this.closed = true;
    if (instance != null) {
        final Server server = instance.getTomcat().getServer();
        if (StandardServer.class.isInstance(server)) {
            StandardServer.class.cast(server).stopAwait();
        }
    }
}
 

private Server getServer() {
    if (container instanceof Server) {
        return (Server) container;
    }
    if (container instanceof Context) {
        // Could do this in one go. Lots of casts so split out for clarity
        Engine engine =
            (Engine) ((Context) container).getParent().getParent();
        return engine.getService().getServer();
    }
    return null;
}
 

/**
 * Listens for {@link LifecycleEvent} for the start of the {@link Server} to
 * initialize itself and then for after_stop events of each {@link Context}.
 */
@Override
public void lifecycleEvent(LifecycleEvent event) {
    try {
        Lifecycle lifecycle = event.getLifecycle();
        if (Lifecycle.AFTER_START_EVENT.equals(event.getType()) &&
                lifecycle instanceof Server) {
            // when the server starts, we register ourself as listener for
            // all context
            // as well as container event listener so that we know when new
            // Context are deployed
            Server server = (Server) lifecycle;
            registerListenersForServer(server);
        }

        if (Lifecycle.BEFORE_STOP_EVENT.equals(event.getType()) &&
                lifecycle instanceof Server) {
            // Server is shutting down, so thread pools will be shut down so
            // there is no need to clean the threads
            serverStopping = true;
        }

        if (Lifecycle.AFTER_STOP_EVENT.equals(event.getType()) &&
                lifecycle instanceof Context) {
            stopIdleThreads((Context) lifecycle);
        }
    } catch (Exception e) {
        String msg =
            sm.getString(
                "threadLocalLeakPreventionListener.lifecycleEvent.error",
                event);
        log.error(msg, e);
    }
}
 

/**
 * Stop an existing server instance.
 */
public void stop() {

    try {
        // Remove the ShutdownHook first so that server.stop()
        // doesn't get invoked twice
        if (useShutdownHook) {
            Runtime.getRuntime().removeShutdownHook(shutdownHook);

            // If JULI is being used, re-enable JULI's shutdown to ensure
            // log messages are not lost
            LogManager logManager = LogManager.getLogManager();
            if (logManager instanceof ClassLoaderLogManager) {
                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                        true);
            }
        }
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // This will fail on JDK 1.2. Ignoring, as Tomcat can run
        // fine without the shutdown hook.
    }

    // Shut down the server
    try {
        Server s = getServer();
        LifecycleState state = s.getState();
        if (LifecycleState.STOPPING_PREP.compareTo(state) <= 0
                && LifecycleState.DESTROYED.compareTo(state) >= 0) {
            // Nothing to do. stop() was already called
        } else {
            s.stop();
            s.destroy();
        }
    } catch (LifecycleException e) {
        log.error("Catalina.stop", e);
    }

}
 

/**
 * Remove an existing Service.
 *
 * @param name MBean Name of the component to remove
 *
 * @exception Exception if a component cannot be removed
 */
public void removeService(String name) throws Exception {

    if (!(container instanceof Server)) {
        throw new Exception();
    }
    
    // Acquire a reference to the component to be removed
    ObjectName oname = new ObjectName(name);
    Service service = getService(oname); 
    ((Server) container).removeService(service);
}
 

@Override
public void accept(final Tomcat tomcat) {
    final Server server = tomcat.getServer();
    server.addLifecycleListener(event -> {
        if (Server.class.isInstance(event.getData()) && Lifecycle.AFTER_DESTROY_EVENT.equals(event.getType())
                && Boolean.getBoolean("talend.component.exit-on-destroy")) {
            System.exit(0);
        }
    });
    // if we want it to be really configurable we should add it in ComponentServerConfiguration
    // and set this instance in the standard context to be able to configure it from cdi side
    final boolean dev = Boolean.getBoolean("talend.component.server.tomcat.valve.error.debug");
    if (!dev) {
        Stream
                .of(server.findServices())
                .map(Service::getContainer)
                .flatMap(e -> Stream.of(e.findChildren()))
                .filter(StandardHost.class::isInstance)
                .map(StandardHost.class::cast)
                .forEach(host -> host.addLifecycleListener(event -> {
                    if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
                        StandardHost.class
                                .cast(host)
                                .setErrorReportValveClass(MinimalErrorReportValve.class.getName());
                    }
                }));
    }
}
 

/**
 * Stop an existing server instance.
 */
public void stop() {

    try {
        // Remove the ShutdownHook first so that server.stop()
        // doesn't get invoked twice
        if (useShutdownHook) {
            Runtime.getRuntime().removeShutdownHook(shutdownHook);

            // If JULI is being used, re-enable JULI's shutdown to ensure
            // log messages are not lost
            LogManager logManager = LogManager.getLogManager();
            if (logManager instanceof ClassLoaderLogManager) {
                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                        true);
            }
        }
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // This will fail on JDK 1.2. Ignoring, as Tomcat can run
        // fine without the shutdown hook.
    }

    // Shut down the server
    try {
        Server s = getServer();
        LifecycleState state = s.getState();
        if (LifecycleState.STOPPING_PREP.compareTo(state) <= 0
                && LifecycleState.DESTROYED.compareTo(state) >= 0) {
            // Nothing to do. stop() was already called
        } else {
            s.stop();
            s.destroy();
        }
    } catch (LifecycleException e) {
        log.error("Catalina.stop", e);
    }

}
 

public TomcatSecurityService() {
    final Server server = TomcatHelper.getServer();
    for (final Service service : server.findServices()) {
        if (service.getContainer() instanceof Engine) {
            final Engine engine = (Engine) service.getContainer();
            if (engine.getRealm() != null) {
                defaultRealm = engine.getRealm();
                break;
            }
        }
    }
}
 

@Override
public void lifecycleEvent(final LifecycleEvent event) {
    if (Server.class.isInstance(event.getSource()) && Lifecycle.AFTER_DESTROY_EVENT.equals(event.getType())) {
        final Collection<Runnable> copy = new ArrayList<>(CaptureLog4j2ShutdownHooks.HOOKS);
        CaptureLog4j2ShutdownHooks.HOOKS.removeAll(copy);
        for (final Runnable runnable : copy) {
            runnable.run();
        }
    }
}
 

private void registerListenersForServer(Server server) {
    for (Service service : server.findServices()) {
        Engine engine = (Engine) service.getContainer();
        engine.addContainerListener(this);
        registerListenersForEngine(engine);
    }

}
 

private void registerListenersForServer(Server server) {
    for (Service service : server.findServices()) {
        Engine engine = (Engine) service.getContainer();
        engine.addContainerListener(this);
        registerListenersForEngine(engine);
    }

}
 

/**
 * Listens for {@link LifecycleEvent} for the start of the {@link Server} to
 * initialize itself and then for after_stop events of each {@link Context}.
 */
@Override
public void lifecycleEvent(LifecycleEvent event) {
    try {
        Lifecycle lifecycle = event.getLifecycle();
        if (Lifecycle.AFTER_START_EVENT.equals(event.getType()) &&
                lifecycle instanceof Server) {
            // when the server starts, we register ourself as listener for
            // all context
            // as well as container event listener so that we know when new
            // Context are deployed
            Server server = (Server) lifecycle;
            registerListenersForServer(server);
        }

        if (Lifecycle.BEFORE_STOP_EVENT.equals(event.getType()) &&
                lifecycle instanceof Server) {
            // Server is shutting down, so thread pools will be shut down so
            // there is no need to clean the threads
            serverStopping = true;
        }

        if (Lifecycle.AFTER_STOP_EVENT.equals(event.getType()) &&
                lifecycle instanceof Context) {
            stopIdleThreads((Context) lifecycle);
        }
    } catch (Exception e) {
        String msg =
            sm.getString(
                "threadLocalLeakPreventionListener.lifecycleEvent.error",
                event);
        log.error(msg, e);
    }
}
 

private Server getServer() {
    if (container instanceof Server) {
        return (Server) container;
    }
    if (container instanceof Context) {
        // Could do this in one go. Lots of casts so split out for clarity
        Engine engine =
            (Engine) ((Context) container).getParent().getParent();
        return engine.getService().getServer();
    }
    return null;
}
 

/**
 * Remove an existing Service.
 *
 * @param name MBean Name of the component to remove
 *
 * @exception Exception if a component cannot be removed
 */
public void removeService(String name) throws Exception {

    if (!(container instanceof Server)) {
        throw new Exception();
    }
    
    // Acquire a reference to the component to be removed
    ObjectName oname = new ObjectName(name);
    Service service = getService(oname); 
    ((Server) container).removeService(service);
}
 

private static void configureServer(Server server) {
  //server.addLifecycleListener(new SecurityListener());
  //server.addLifecycleListener(new AprLifecycleListener());
  LifecycleListener jasperListener = new JasperListener();
  server.addLifecycleListener(jasperListener);
  jasperListener.lifecycleEvent(new LifecycleEvent(server, Lifecycle.BEFORE_INIT_EVENT, null));
  server.addLifecycleListener(new JreMemoryLeakPreventionListener());
  //server.addLifecycleListener(new GlobalResourcesLifecycleListener());
  server.addLifecycleListener(new ThreadLocalLeakPreventionListener());
}