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 javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.annotation.MultipartConfig;
  import javax.servlet.annotation.WebInitParam;
  import javax.servlet.annotation.WebServlet;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.xml.bind.JAXBContext;
  import javax.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);
 
                 TemplateServicee/turbine/services/template/TemplateService.html#TemplateService">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
                 TurbineServicesg/apache/turbine/services/TurbineServices.html#TurbineServices">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"../../../org/apache/turbine/util/RunData.html#RunData">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)
             {
                 LogManager.getContext(null, false, log4jFile.toUri());
             }
         }
         log.info("resolved 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);
     }
 }