/**
* This file Copyright (c) 2003-2012 Magnolia International
* Ltd. (http://www.magnolia-cms.com). All rights reserved.
*
*
* This file is dual-licensed under both the Magnolia
* Network Agreement and the GNU General Public License.
* You may elect to use one or the other of these licenses.
*
* This file is distributed in the hope that it will be
* useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A
* PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
* Redistribution, except as permitted by whichever of the GPL
* or MNA you select, is prohibited.
*
* 1. For the GPL license (GPL), you can redistribute and/or
* modify this file under the terms of the GNU General
* Public License, Version 3, as published by the Free Software
* Foundation. You should have received a copy of the GNU
* General Public License, Version 3 along with this program;
* if not, write to the Free Software Foundation, Inc., 51
* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* 2. For the Magnolia Network Agreement (MNA), this file
* and the accompanying materials are made available under the
* terms of the MNA which accompanies this distribution, and
* is available at http://www.magnolia-cms.com/mna.html
*
* Any modifications to this file must keep this entire header
* intact.
*
*/
package info.magnolia.init;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import javax.inject.Singleton;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.inject.Stage;
import info.magnolia.cms.beans.config.ConfigLoader;
import info.magnolia.cms.core.SystemProperty;
import info.magnolia.context.MgnlContext;
import info.magnolia.logging.Log4jConfigurer;
import info.magnolia.module.ModuleManager;
import info.magnolia.module.ModuleRegistry;
import info.magnolia.objectfactory.Components;
import info.magnolia.objectfactory.configuration.ComponentProviderConfigurationBuilder;
import info.magnolia.objectfactory.configuration.ComponentProviderConfiguration;
import info.magnolia.objectfactory.guice.GuiceComponentProvider;
import info.magnolia.objectfactory.guice.GuiceComponentProviderBuilder;
/**
* Point of entry for Magnolia CMS, initializes the component providers, starts logging, triggers loading of
* properties and finally delegates to {@link ConfigLoader} for completing initialization.
*
* <h3>Component providers</h3>
* <p>
* When Magnolia starts up the first thing that happens is the creation of the <i>platform</i> component provider. It
* contains the essential singletons that constitutes the platform on which the rest of the system builds. These
* components are defined in a file called <code>platform-components.xml</code>, it's on the classpath in package
* /info/magnolia/init.
* </p>
* <p>
* The location can be customized using a servlet context parameter called
* <code>magnolia.platform.components.config.location</code>. It's specified as a list of comma-separated files on the
* classpath. The files are loaded in the specified order allowing definitions to override definitions from earlier
* files.
* </p>
* <pre>
* <context-param>
* <param-name>magnolia.platform.components.config.location</param-name>
* <param-value>/info/magnolia/init/platform-components.xml,/com/mycompany/custom-platform-components.xml</param-value>
* </context-param>
* </pre>
* <p>
* The platform components include the {@link ModuleManager} which is called by this listener to load the descriptors of
* all the modules present. Modules define additional components that are loaded into a second component provider called
* <i>system</i>.
* </p>
* <p>
* When {@link ConfigLoader} takes over the initialization procedure it will create a third component provider called
* <i>main</i> which contain components defined in modules as belonging to the main component provider.
* </p>
* <h3>Property loading</h3>
* <p>
* Properties are loaded by an implementation of {@link MagnoliaConfigurationProperties}. It's configured as a platform
* component and is called by this class to do initialization. See {@link DefaultMagnoliaPropertiesResolver} and
* {@link DefaultMagnoliaInitPaths} for details on how to customize the default behavior.
* </p>
*
* @version $Id$
* @see ModuleManager
* @see MagnoliaInitPaths
* @see MagnoliaPropertiesResolver
* @see DefaultMagnoliaPropertiesResolver
* @see DefaultMagnoliaConfigurationProperties
* @see DefaultMagnoliaInitPaths
* @see ConfigLoader
* @see Log4jConfigurer
*/
@Singleton
public class MagnoliaServletContextListener implements ServletContextListener {
public static final String PLATFORM_COMPONENTS_CONFIG_LOCATION_NAME = "magnolia.platform.components.config.location";
public static final String DEFAULT_PLATFORM_COMPONENTS_CONFIG_LOCATION = "/info/magnolia/init/platform-components.xml";
private static final Logger log = LoggerFactory.getLogger(MagnoliaServletContextListener.class);
private ServletContext servletContext;
private GuiceComponentProvider platform;
private GuiceComponentProvider system;
private ModuleManager moduleManager;
private ConfigLoader loader;
@Override
public void contextInitialized(final ServletContextEvent sce) {
contextInitialized(sce, true);
}
public void contextInitialized(final ServletContextEvent sce, boolean startServer) {
try {
servletContext = sce.getServletContext();
// Start 'platform' ComponentProvider
GuiceComponentProviderBuilder builder = new GuiceComponentProviderBuilder();
builder.withConfiguration(getPlatformComponents());
builder.inStage(Stage.PRODUCTION);
builder.exposeGlobally();
platform = builder.build();
// Expose server name as a system property, so it can be used in log4j configurations
// rootPath and webapp are not exposed since there can be different webapps running in the same jvm
String serverName = platform.getComponent(MagnoliaInitPaths.class).getServerName();
if (serverName == null) {
log.warn("Failed to obtain server name, please check your configuration. Using 'default' as server name instead.");
serverName = "default";
}
System.setProperty("server", serverName);
// Load module definitions
moduleManager = platform.getComponent(ModuleManager.class);
moduleManager.loadDefinitions();
// Initialize MagnoliaConfigurationProperties
MagnoliaConfigurationProperties configurationProperties = platform.getComponent(MagnoliaConfigurationProperties.class);
configurationProperties.init();
log.info("Property sources loaded: {}", configurationProperties.describe());
// Connect legacy properties to the MagnoliaConfigurationProperties object
SystemProperty.setMagnoliaConfigurationProperties(configurationProperties);
// Initialize logging now that properties are available
Log4jConfigurer.initLogging();
// Start 'system' ComponentProvider
builder = new GuiceComponentProviderBuilder();
builder.withConfiguration(getSystemComponents());
builder.withParent(platform);
builder.exposeGlobally();
system = builder.build();
// Delegate to ConfigLoader to complete initialization
loader = system.getComponent(ConfigLoader.class);
if (startServer) {
startServer();
}
} catch (Throwable t) {
log.error("Oops, Magnolia could not be started", t);
t.printStackTrace();
if (t instanceof Error) {
throw (Error) t;
}
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
}
throw new RuntimeException(t);
}
}
@Override
public void contextDestroyed(final ServletContextEvent sce) {
// avoid disturbing NPEs if the context has never been started (classpath problems, etc)
if (moduleManager != null) {
moduleManager.stopModules();
}
stopServer();
// We set the global ComponentProvider to its parent here, then we destroy it, components in it that expects the
// global ComponentProvider to be the one it lives in and the one that was there when the component was created
// might fail because of this. Maybe we can solve it by using the ThreadLocal override we already have and call
// scopes.
if (system != null) {
Components.setComponentProvider(system.getParent());
system.destroy();
}
if (platform != null) {
Components.setComponentProvider(platform.getParent());
platform.destroy();
}
Log4jConfigurer.shutdownLogging();
}
protected ComponentProviderConfiguration getPlatformComponents() {
ComponentProviderConfigurationBuilder configurationBuilder = new ComponentProviderConfigurationBuilder();
List<String> resources = getPlatformComponentsResources();
ComponentProviderConfiguration platformComponents = configurationBuilder.readConfiguration(resources, "platform");
platformComponents.registerInstance(ServletContext.class, servletContext);
// This is needed by DefaultMagnoliaInitPaths for backwards compatibility
platformComponents.registerInstance(MagnoliaServletContextListener.class, this);
return platformComponents;
}
/**
* Returns a list of resources that contain platform components. Definitions for the same type will override giving
* preference to the last read definition. Checks for an init parameter in web.xml for an overridden location
* Subclasses can override this method to provide alternative strategies. The returned locations are used to find
* the resource on the class path.
*/
protected List<String> getPlatformComponentsResources() {
String configLocation = servletContext.getInitParameter(PLATFORM_COMPONENTS_CONFIG_LOCATION_NAME);
if (StringUtils.isNotBlank(configLocation)) {
return Arrays.asList(StringUtils.split(configLocation, ", \n"));
}
return Collections.singletonList(DEFAULT_PLATFORM_COMPONENTS_CONFIG_LOCATION);
}
protected ComponentProviderConfiguration getSystemComponents() {
ComponentProviderConfigurationBuilder configurationBuilder = new ComponentProviderConfigurationBuilder();
return configurationBuilder.getComponentsFromModules("system", platform.getComponent(ModuleRegistry.class).getModuleDefinitions());
}
protected void startServer() {
MgnlContext.doInSystemContext(new MgnlContext.VoidOp() {
@Override
public void doExec() {
loader.load();
}
}, true);
}
protected void stopServer() {
if (loader != null) {
MgnlContext.doInSystemContext(new MgnlContext.VoidOp() {
@Override
public void doExec() {
loader.unload();
}
}, true);
}
}
/**
* @deprecated since 4.5, use or subclass {@link MagnoliaInitPaths}.
*/
protected String initWebappName(String rootPath) {
return null;
}
/**
* @deprecated since 4.5, use or subclass {@link MagnoliaInitPaths}.
*/
protected String initRootPath(final ServletContext context) {
return null;
}
/**
* @deprecated since 4.5, use or subclass {@link MagnoliaInitPaths}.
*/
protected String initServername(boolean unqualified) {
return null;
}
}