Turbine.java
package org.apache.turbine;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.MultipartConfig;
import jakarta.servlet.annotation.WebInitParam;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Unmarshaller;
import org.apache.commons.configuration2.Configuration;
import org.apache.commons.configuration2.PropertiesConfiguration;
import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
import org.apache.commons.configuration2.builder.combined.CombinedConfigurationBuilder;
import org.apache.commons.configuration2.builder.fluent.Parameters;
import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.commons.configuration2.io.HomeDirectoryLocationStrategy;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.turbine.modules.PageLoader;
import org.apache.turbine.pipeline.Pipeline;
import org.apache.turbine.pipeline.PipelineData;
import org.apache.turbine.pipeline.TurbinePipeline;
import org.apache.turbine.services.Initable;
import org.apache.turbine.services.InitializationException;
import org.apache.turbine.services.ServiceManager;
import org.apache.turbine.services.TurbineServices;
import org.apache.turbine.services.rundata.RunDataService;
import org.apache.turbine.services.template.TemplateService;
import org.apache.turbine.util.LocaleUtils;
import org.apache.turbine.util.RunData;
import org.apache.turbine.util.ServerData;
import org.apache.turbine.util.TurbineConfig;
import org.apache.turbine.util.TurbineException;
import org.apache.turbine.util.uri.URIConstants;
/**
* <p>
* Turbine is the main servlet for the entire system. If you need to perform
* initialization of a service, then you should implement the Services API and
* let your code be initialized by it.
* </p>
*
* <p>
* Turbine servlet recognizes the following initialization parameters.
* </p>
*
* <ul>
* <li><code>properties</code> the path to TurbineResources.properties file used
* to configure Turbine, relative to the application root.</li>
* <li><code>configuration</code> the path to TurbineConfiguration.xml file used
* to configure Turbine from various sources, relative to the application
* root.</li>
* <li><code>applicationRoot</code> this parameter defaults to the web context
* of the servlet container. You can use this parameter to specify the directory
* within the server's filesystem, that is the base of your web
* application.</li>
* </ul>
*
* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
* @author <a href="mailto:bmclaugh@algx.net">Brett McLaughlin</a>
* @author <a href="mailto:greg@shwoop.com">Greg Ritter</a>
* @author <a href="mailto:john.mcnally@clearink.com">John D. McNally</a>
* @author <a href="mailto:frank.kim@clearink.com">Frank Y. Kim</a>
* @author <a href="mailto:krzewski@e-point.pl">Rafal Krzewski</a>
* @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
* @author <a href="mailto:sean@informage.net">Sean Legassick</a>
* @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
* @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
* @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
* @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
* @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
* @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
* @version $Id$
*/
@WebServlet(name = "Turbine", urlPatterns = { "/app" }, loadOnStartup = 1, initParams = {
@WebInitParam(name = TurbineConstants.APPLICATION_ROOT_KEY, value = TurbineConstants.APPLICATION_ROOT_DEFAULT),
@WebInitParam(name = TurbineConfig.PROPERTIES_PATH_KEY, value = TurbineConfig.PROPERTIES_PATH_DEFAULT) })
@MultipartConfig
public class Turbine extends HttpServlet
{
/** Serial version */
private static final long serialVersionUID = -6317118078613623990L;
/**
* Name of path info parameter used to indicate the redirected stage of a
* given user's initial Turbine request
*
* @deprecated
*/
@Deprecated // not used
public static final String REDIRECTED_PATHINFO_NAME = "redirected";
/**
* The base directory key @deprecated
*/
@Deprecated // not used
public static final String BASEDIR_KEY = "basedir";
/**
* In certain situations the init() method is called more than once,
* sometimes even concurrently. This causes bad things to happen, so we use
* this flag to prevent it.
*/
private static boolean firstInit = true;
/**
* The pipeline to use when processing requests.
*/
private static Pipeline pipeline = null;
/** Whether init succeeded or not. */
private static Throwable initFailure = null;
/**
* Should initialization activities be performed during doGet() execution?
*/
private static boolean firstDoGet = true;
/**
* Keep all the properties of the web server in a convenient data structure
*/
private static volatile ServerData serverData = null;
/** The base from which the Turbine application will operate. */
private static String applicationRoot;
/** Servlet config for this Turbine webapp. */
private static ServletConfig servletConfig;
/** Servlet context for this Turbine webapp. */
private static ServletContext servletContext;
/**
* The webapp root where the Turbine application is running in the servlet
* container. This might differ from the application root.
*/
private static String webappRoot;
/** Our internal configuration object */
private static Configuration configuration = null;
/** Which configuration method is being used */
private enum ConfigurationStyle
{
XML, PROPERTIES, JSON, YAML, UNSET
}
private static final Logger log = LogManager.getLogger(Turbine.class);
/**
* This init method will load the default resources from a properties file.
*
* This method is called by init(ServletConfig config)
*
* @throws ServletException
* a servlet exception.
*/
@Override
public void init() throws ServletException
{
synchronized (Turbine.class)
{
super.init();
if (!firstInit)
{
log.info("Double initialization of Turbine was attempted!");
return;
}
// executing init will trigger some static initializers, so we have
// only one chance.
firstInit = false;
ServletConfig config = getServletConfig();
try
{
ServletContext context = config.getServletContext();
configure(config, context);
TemplateService templateService = (TemplateService) getServiceManager().getService(TemplateService.SERVICE_NAME);
if (templateService == null)
{
throw new TurbineException("No Template Service configured!");
}
if (getRunDataService() == null)
{
throw new TurbineException("No RunData Service configured!");
}
}
catch (Throwable e)
{
// save the exception to complain loudly later :-)
initFailure = e;
log.fatal("Turbine: init() failed", e);
throw new ServletException("Turbine: init() failed", e);
}
log.info("Turbine: init() Ready to Rumble!");
}
}
/**
* Read the master configuration file in, configure logging and start up any
* early services.
*
* @param config
* The Servlet Configuration supplied by the container
* @param context
* The Servlet Context supplied by the container
*
* @throws Exception
* A problem occurred while reading the configuration or
* performing early startup
*/
protected void configure(ServletConfig config, ServletContext context)
throws Exception
{
// Set the application root. This defaults to the webapp
// context if not otherwise set.
applicationRoot = findInitParameter(context, config,
TurbineConstants.APPLICATION_ROOT_KEY,
TurbineConstants.APPLICATION_ROOT_DEFAULT);
webappRoot = context.getRealPath("/");
// log.info("Web Application root is " + webappRoot);
// log.info("Application root is " + applicationRoot);
if (applicationRoot == null || applicationRoot.equals(TurbineConstants.WEB_CONTEXT))
{
applicationRoot = webappRoot;
// log.info("got empty or 'webContext' Application root. Application
// root now: " + applicationRoot);
}
// Set the applicationRoot for this webapp.
setApplicationRoot(applicationRoot);
//
// Now we run the Turbine configuration code. There are two ways
// to configure Turbine:
//
// a) By supplying an web.xml init parameter called "configuration"
//
// <init-param>
// <param-name>configuration</param-name>
// <param-value>/WEB-INF/conf/turbine.xml</param-value>
// </init-param>
//
// This loads an XML based configuration file.
//
// b) By supplying an web.xml init parameter called "properties"
//
// <init-param>
// <param-name>properties</param-name>
// <param-value>/WEB-INF/conf/TurbineResources.properties</param-value>
// </init-param>
//
// This loads a Properties based configuration file. Actually, these are
// extended properties as provided by commons-configuration
//
// If neither a) nor b) is supplied, Turbine will fall back to the
// known behaviour of loading a properties file called
// /WEB-INF/conf/TurbineResources.properties relative to the
// web application root.
Path confPath = configureApplication(config, context);
configureLogging(confPath);
//
// Logging with log4j 2 is done via convention, finding in path
setTurbineServletConfig(config);
setTurbineServletContext(context);
getServiceManager().setApplicationRoot(applicationRoot);
// We want to set a few values in the configuration so
// that ${variable} interpolation will work for
//
// ${applicationRoot}
// ${webappRoot}
configuration.setProperty(TurbineConstants.APPLICATION_ROOT_KEY, applicationRoot);
configuration.setProperty(TurbineConstants.WEBAPP_ROOT_KEY, webappRoot);
getServiceManager().setConfiguration(configuration);
// Initialize the service manager. Services
// that have its 'earlyInit' property set to
// a value of 'true' will be started when
// the service manager is initialized.
getServiceManager().init();
// Retrieve the pipeline class and then initialize it. The pipeline
// handles the processing of a webrequest/response cycle.
String descriptorPath = configuration.getString(
"pipeline.default.descriptor",
TurbinePipeline.CLASSIC_PIPELINE);
log.debug("Using descriptor path: {}", descriptorPath);
// context resource path has to begin with slash, cft.
// context.getResource
if (!descriptorPath.startsWith("/"))
{
descriptorPath = "/" + descriptorPath;
}
try (InputStream reader = context.getResourceAsStream(descriptorPath))
{
JAXBContext jaxb = JAXBContext.newInstance(TurbinePipeline.class);
Unmarshaller unmarshaller = jaxb.createUnmarshaller();
pipeline = (Pipeline) unmarshaller.unmarshal(reader);
}
log.debug("Initializing pipeline");
pipeline.initialize();
}
/**
* Checks configuraton style, resolves the location of the configuration and
* loads it to internal {@link Configuration} object
* ({@link #configuration}).
*
* Allows reading from a {@link CombinedConfigurationBuilder} xml configuration file.
*
* @param config
* the Servlet Configuration
* @param context
* Servlet Context
* @return The resolved Configuration Path
* @throws IOException
* if configuration path not found
* @throws ConfigurationException
* if failed to configure
*/
protected Path configureApplication(ServletConfig config, ServletContext context)
throws IOException, ConfigurationException
{
ConfigurationStyle confStyle = ConfigurationStyle.UNSET;
// first test
String confFile = findInitParameter(context, config,
TurbineConfig.CONFIGURATION_PATH_KEY,
null);
if (StringUtils.isNotEmpty(confFile))
{
confStyle = ConfigurationStyle.XML;
}
else // second test
{
confFile = findInitParameter(context, config,
TurbineConfig.PROPERTIES_PATH_KEY,
null);
if (StringUtils.isNotEmpty(confFile))
{
confStyle = ConfigurationStyle.PROPERTIES;
}
}
// more tests ..
// last test
if (confStyle == ConfigurationStyle.UNSET)
{ // last resort
confFile = findInitParameter(context, config,
TurbineConfig.PROPERTIES_PATH_KEY,
TurbineConfig.PROPERTIES_PATH_DEFAULT);
confStyle = ConfigurationStyle.PROPERTIES;
}
// First report
log.debug("Loading configuration ({}) from {}", confStyle, confFile);
// now begin loading
Parameters params = new Parameters();
File confPath = getApplicationRootAsFile();
if (confFile.startsWith("/"))
{
confFile = confFile.substring(1); // cft. RFC2396 should not start
// with a slash, if not absolute
// path
}
Path confFileRelativePath = Paths.get(confFile);// relative to later
// join
Path targetPath = Paths.get(confPath.toURI());
targetPath = targetPath.resolve(confFileRelativePath);
// Get the target path directory
Path targetPathDirectory = targetPath.getParent();
if (targetPathDirectory != null)
{
// set the configuration path
confPath = targetPathDirectory.normalize().toFile();
Path targetFilePath = targetPath.getFileName();
if (targetFilePath != null)
{
// set the configuration file name
confFile = targetFilePath.toString();
}
}
switch (confStyle)
{
case XML:
// relative base path used for this and child configuration
// files
CombinedConfigurationBuilder combinedBuilder = new CombinedConfigurationBuilder()
.configure(params.fileBased()
.setFileName(confFile)
.setListDelimiterHandler(new DefaultListDelimiterHandler(','))
.setLocationStrategy(new HomeDirectoryLocationStrategy(confPath.getCanonicalPath(), false)));
configuration = combinedBuilder.getConfiguration();
break;
case PROPERTIES:
FileBasedConfigurationBuilder<PropertiesConfiguration> propertiesBuilder = new FileBasedConfigurationBuilder<>(
PropertiesConfiguration.class)
.configure(params.properties()
.setFileName(confFile)
.setListDelimiterHandler(new DefaultListDelimiterHandler(','))
.setLocationStrategy(new HomeDirectoryLocationStrategy(confPath.getCanonicalPath(), false)));
// meta configuration: this may contain any commons configuration: system<>, jndi, env
configuration = propertiesBuilder.getConfiguration();
break;
case JSON:
case YAML:
throw new NotImplementedException("JSON or XAML configuration style not yet implemented!");
default:
break;
}
// Now report our successful configuration to the world
log.info("Loaded configuration ({}) from {} style: {}",
confStyle, confFile, configuration.toString());
return targetPath;
}
/**
* Finds the specified servlet configuration/initialization parameter,
* looking first for a servlet-specific parameter, then for a global
* parameter, and using the provided default if not found.
*
* @param context
* the servlet context
* @param config
* configuration object
* @param name
* name of parameter
* @param defaultValue
* of the parameter
* @return String value of the parameter
*/
protected String findInitParameter(ServletContext context,
ServletConfig config, String name, String defaultValue)
{
String path = null;
String parameterName = name;
// Try the name as provided first.
boolean usingNamespace = parameterName.startsWith(TurbineConstants.CONFIG_NAMESPACE);
while (true)
{
path = config.getInitParameter(parameterName);
if (StringUtils.isEmpty(path))
{
path = context.getInitParameter(parameterName);
if (StringUtils.isEmpty(path))
{
// The named parameter didn't yield a value.
if (usingNamespace)
{
path = defaultValue;
}
else
{
// Try again using Turbine's namespace.
parameterName = TurbineConstants.CONFIG_NAMESPACE + '.' + parameterName;
usingNamespace = true;
continue;
}
}
}
break;
}
return path;
}
/**
* Initializes the services which need <code>PipelineData</code> to
* initialize themselves (post startup).
*
* @param data
* The first <code>GET</code> request.
*/
public void init(PipelineData data)
{
synchronized (Turbine.class)
{
if (firstDoGet)
{
// All we want to do here is save some servlet
// information so that services and processes
// that don't have direct access to a RunData
// object can still know something about
// the servlet environment.
saveServletInfo(data);
// Initialize services with the PipelineData instance
TurbineServices services = (TurbineServices) getServiceManager();
for (Iterator<String> i = services.getServiceNames(); i.hasNext();)
{
String serviceName = i.next();
Object service = services.getService(serviceName);
if (service instanceof Initable)
{
try
{
((Initable) service).init(data);
}
catch (InitializationException e)
{
log.warn("Could not initialize Initable {} with PipelineData", serviceName, e);
}
}
}
// Mark that we're done.
firstDoGet = false;
log.info("Turbine: first Request successful");
}
}
}
/**
* Return the current configuration with all keys included
*
* @return a Configuration Object
*/
public static Configuration getConfiguration()
{
return configuration;
}
/**
* Return the server name.
*
* @return String server name
*/
public static String getServerName()
{
return getDefaultServerData().getServerName();
}
/**
* Return the server scheme.
*
* @return String server scheme
*/
public static String getServerScheme()
{
return getDefaultServerData().getServerScheme();
}
/**
* Return the server port.
*
* @return String server port
*/
public static String getServerPort()
{
return Integer.toString(getDefaultServerData().getServerPort());
}
/**
* Get the script name. This is the initial script name. Actually this is
* probably not needed any more. I'll check. jvz.
*
* @return String initial script name.
*/
public static String getScriptName()
{
return getDefaultServerData().getScriptName();
}
/**
* Return the context path.
*
* @return String context path
*/
public static String getContextPath()
{
return getDefaultServerData().getContextPath();
}
/**
* Return all the Turbine Servlet information (Server Name, Port, Scheme in
* a ServerData structure. This is generated from the values set when
* initializing the Turbine and may not be correct if you're running in a
* clustered structure. You can provide default values in your configuration
* for cases where access is requied before your application is first
* accessed by a user. This might be used if you need a DataURI and have no
* RunData object handy.
*
* @return An initialized ServerData object
*/
public static ServerData getDefaultServerData()
{
if (serverData == null)
{
String serverName = configuration.getString(TurbineConstants.DEFAULT_SERVER_NAME_KEY);
if (serverName == null)
{
log.error("ServerData Information requested from Turbine before first request!");
}
else
{
log.info("ServerData Information retrieved from configuration.");
}
// Will be overwritten once the first request is run;
serverData = new ServerData(serverName,
configuration.getInt(TurbineConstants.DEFAULT_SERVER_PORT_KEY,
URIConstants.HTTP_PORT),
configuration.getString(TurbineConstants.DEFAULT_SERVER_SCHEME_KEY,
URIConstants.HTTP),
configuration.getString(TurbineConstants.DEFAULT_SCRIPT_NAME_KEY),
configuration.getString(TurbineConstants.DEFAULT_CONTEXT_PATH_KEY));
}
return serverData;
}
/**
* Set the servlet config for this turbine webapp.
*
* @param config
* New servlet config
*/
public static void setTurbineServletConfig(ServletConfig config)
{
servletConfig = config;
}
/**
* Get the servlet config for this turbine webapp.
*
* @return ServletConfig
*/
public static ServletConfig getTurbineServletConfig()
{
return servletConfig;
}
/**
* Set the servlet context for this turbine webapp.
*
* @param context
* New servlet context.
*/
public static void setTurbineServletContext(ServletContext context)
{
servletContext = context;
}
/**
* Get the servlet context for this turbine webapp.
*
* @return ServletContext
*/
public static ServletContext getTurbineServletContext()
{
return servletContext;
}
/**
* The <code>Servlet</code> destroy method. Invokes
* <code>ServiceBroker</code> tear down method.
*/
@Override
public void destroy()
{
// Shut down all Turbine Services.
getServiceManager().shutdownServices();
firstInit = true;
firstDoGet = true;
log.info("Turbine: Done shutting down!");
}
/**
* The primary method invoked when the Turbine servlet is executed.
*
* @param req
* Servlet request.
* @param res
* Servlet response.
* @throws IOException
* a servlet exception.
* @throws ServletException
* a servlet exception.
*/
@Override
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws IOException, ServletException
{
// Check to make sure that we started up properly.
if (initFailure != null)
{
handleHorribleException(res, initFailure);
return;
}
// Get general PipelineData here...
try (PipelineData pipelineData = getRunDataService().getRunData(req, res, getServletConfig()))
{
try
{
// Perform turbine specific initialization below.
Map<Class<?>, Object> runDataMap = new HashMap<>();
runDataMap.put(RunData.class, pipelineData);
// put the data into the pipeline
pipelineData.put(RunData.class, runDataMap);
// If this is the first invocation, perform some
// initialization. Certain services need RunData to initialize
// themselves.
if (firstDoGet)
{
init(pipelineData);
}
// Stages of Pipeline implementation execution
// configurable via attached Valve implementations in a
// XML properties file.
pipeline.invoke(pipelineData);
}
catch (Throwable t)
{
handleException(pipelineData, res, t);
}
}
catch (Throwable t)
{
handleHorribleException(res, t);
}
}
/**
* In this application doGet and doPost are the same thing.
*
* @param req
* Servlet request.
* @param res
* Servlet response.
* @throws IOException
* a servlet exception.
* @throws ServletException
* a servlet exception.
*/
@Override
public void doPost(HttpServletRequest req, HttpServletResponse res)
throws IOException, ServletException
{
doGet(req, res);
}
/**
* Return the servlet info.
*
* @return a string with the servlet information.
*/
@Override
public String getServletInfo()
{
return "Turbine Servlet";
}
/**
* This method is about making sure that we catch and display errors to the
* screen in one fashion or another. What happens is that it will attempt to
* show the error using your user defined Error Screen. If that fails, then
* it will resort to just displaying the error and logging it all over the
* place including the servlet engine log file, the Turbine log file and on
* the screen.
*
* @param pipelineData
* A Turbine PipelineData object.
* @param res
* Servlet response.
* @param t
* The exception to report.
*/
protected void handleException(PipelineData pipelineData, HttpServletResponse res,
Throwable t)
{
RunData data = (RunData) pipelineData;
// make sure that the stack trace makes it the log
log.error("Turbine.handleException: ", t);
try
{
// This is where we capture all exceptions and show the
// Error Screen.
data.setStackTrace(ExceptionUtils.getStackTrace(t), t);
// setup the screen
data.setScreen(configuration.getString(
TurbineConstants.SCREEN_ERROR_KEY,
TurbineConstants.SCREEN_ERROR_DEFAULT));
// do more screen setup for template execution if needed
if (data.getTemplateInfo() != null)
{
data.getTemplateInfo()
.setScreenTemplate(configuration.getString(
TurbineConstants.TEMPLATE_ERROR_KEY,
TurbineConstants.TEMPLATE_ERROR_VM));
}
// Make sure to not execute an action.
data.setAction("");
PageLoader.getInstance().exec(pipelineData,
configuration.getString(TurbineConstants.PAGE_DEFAULT_KEY,
TurbineConstants.PAGE_DEFAULT_DEFAULT));
data.getResponse().setContentType(data.getContentType());
data.getResponse().setStatus(data.getStatusCode());
}
// Attempt to do *something* at this point...
catch (Throwable reallyScrewedNow)
{
handleHorribleException(res, reallyScrewedNow);
}
}
/**
* This method handles exception cases where no PipelineData object exists
*
* @param res
* Servlet response.
* @param t
* The exception to report.
*/
protected void handleHorribleException(HttpServletResponse res, Throwable t)
{
try
{
res.setContentType(TurbineConstants.DEFAULT_TEXT_CONTENT_TYPE);
res.setStatus(200);
PrintWriter writer = res.getWriter();
writer.println("Horrible Exception: ");
t.printStackTrace(writer);
}
catch (Exception ignored)
{
// ignore
}
log.error(t.getMessage(), t);
}
/**
* Save some information about this servlet so that it can be utilized by
* object instances that do not have direct access to PipelineData.
*
* @param data
* Turbine request data
*/
public static synchronized void saveServletInfo(PipelineData data)
{
// Store the context path for tools like ContentURI and
// the UIManager that use webapp context path information
// for constructing URLs.
//
// Bundle all the information above up into a convenient structure
//
ServerData requestServerData = data.get(Turbine.class, ServerData.class);
serverData = (ServerData) requestServerData.clone();
}
/**
* Checks Log4j 2 Context, loads log4File, if configured and configuration
* is not already located.
*
* @param logConf
* Configuration file path
* @throws IOException
* if path not found
*/
protected void configureLogging(Path logConf) throws IOException
{
LoggerContext context = (LoggerContext) LogManager.getContext(false);
if (context.getConfiguration().getConfigurationSource().getLocation() == null)
{
Path log4jFile = resolveLog4j2(logConf.getParent());
// configured + no other log4j configuration already found
if (log4jFile != null)
{
org.apache.logging.log4j.spi.LoggerContext ctxContext = LogManager.getContext(null, false, log4jFile.toUri());
if (ctxContext instanceof LoggerContext) {
log.info("resolved log4j2 location: {}", context.getConfiguration().getConfigurationSource().getLocation());
}
}
}
log.info("found log4j2 location: {}", context.getConfiguration().getConfigurationSource().getLocation());
}
/**
* Check {@linkplain TurbineConstants#LOG4J2_CONFIG_FILE} in Turbine
* configuration.
*
* @param logConfPath
* configuration directory
* @return Resolved log4j2 {@link Path} or null, if not found or configured
* "none".
*/
protected Path resolveLog4j2(Path logConfPath)
{
String log4jFile = configuration.getString(TurbineConstants.LOG4J2_CONFIG_FILE,
TurbineConstants.LOG4J2_CONFIG_FILE_DEFAULT);
if (log4jFile.startsWith("/"))
{
log4jFile = log4jFile.substring(1);
}
Path log4jTarget = null;
if (StringUtils.isNotEmpty(log4jFile) && !log4jFile.equalsIgnoreCase("none"))
{
// log4j must either share path with configuration path or resolved
// relatively
if (logConfPath != null)
{
Path log4jFilePath = Paths.get(log4jFile);
Path logFilePath = logConfPath.resolve(log4jFilePath);
if (logFilePath != null && logFilePath.toFile().exists())
{
log4jTarget = logFilePath.normalize();
}
else
{
// fall back just using the filename, if path match
if (log4jFilePath != null && log4jFilePath.getParent() != null && logConfPath.endsWith(log4jFilePath.getParent()))
{
logFilePath = logConfPath.resolve(log4jFilePath.getFileName());
if (logFilePath != null && logFilePath.toFile().exists())
{
log4jTarget = logFilePath.normalize();
}
}
}
}
}
return log4jTarget;
}
/**
* Set the application root for the webapp.
*
* @param val
* New app root.
*/
public static void setApplicationRoot(String val)
{
applicationRoot = val;
}
/**
* Get the application root for this Turbine webapp.
*
* @return String applicationRoot
*/
public static String getApplicationRoot()
{
return applicationRoot;
}
/**
* Get the application root for this Turbine webapp as a file object.
*
* @return File applicationRootFile
*/
public static File getApplicationRootAsFile()
{
return new File(applicationRoot);
}
/**
* Used to get the real path of configuration and resource information. This
* can be used by an app being developed in a standard CVS layout.
*
* @param path
* path translated to the application root
* @return the real path
*/
public static String getRealPath(String path)
{
if (path.startsWith("/"))
{
return new File(getApplicationRootAsFile(), path.substring(1)).getAbsolutePath();
}
return new File(getApplicationRootAsFile(), path).getAbsolutePath();
}
/**
* Return an instance of the currently configured Service Manager
*
* @return A service Manager instance
*/
private ServiceManager getServiceManager()
{
return TurbineServices.getInstance();
}
/**
* Returns the default input encoding for the servlet.
*
* @return the default input encoding.
*
* @deprecated Use
* {@link org.apache.turbine.pipeline.DefaultSetEncodingValve}
* to set default encoding
*/
@Deprecated
public static String getDefaultInputEncoding()
{
return LocaleUtils.getDefaultInputEncoding();
}
/**
* Static Helper method for looking up the RunDataService
*
* @return A RunDataService
*/
private RunDataService getRunDataService()
{
return (RunDataService) getServiceManager().getService(RunDataService.SERVICE_NAME);
}
}