/*
* This library is part of OpenCms -
* the Open Source Content Management System
*
* Copyright (c) Alkacon Software GmbH (http://www.alkacon.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* For further information about Alkacon Software GmbH, please see the
* company website: http://www.alkacon.com
*
* For further information about OpenCms, please see the
* project website: http://www.opencms.org
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.opencms.main;
import org.opencms.util.A_CmsModeStringEnumeration;
import org.opencms.util.CmsFileUtil;
import org.opencms.util.CmsStringUtil;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import javax.servlet.ServletContext;
import org.apache.commons.logging.Log;
/**
* Stores specific servlet container options, that might influence OpenCms behavior.<p>
*
* @since 7.0.5
*/
public class CmsServletContainerSettings {
/**
* Enumeration class for the configuration mode.<p>
*/
public static final class CmsServletContainerCfgMode extends A_CmsModeStringEnumeration {
/** Auto configuration mode. */
protected static final CmsServletContainerCfgMode MODE_AUTO = new CmsServletContainerCfgMode("auto");
/** Manual configuration mode. */
protected static final CmsServletContainerCfgMode MODE_MANUAL = new CmsServletContainerCfgMode("manual");
/** No set configuration mode. */
protected static final CmsServletContainerCfgMode MODE_NONE = new CmsServletContainerCfgMode("none");
/** Version id required for safe serialization. */
private static final long serialVersionUID = -8191582624108081577L;
/**
* Private constructor.<p>
*
* @param mode the remote command execution return type integer representation
*/
private CmsServletContainerCfgMode(String mode) {
super(mode);
}
/**
* Returns the parsed mode object if the string representation matches, or <code>null</code> if not.<p>
*
* @param mode the string representation to parse
*
* @return the parsed mode object
*/
public static CmsServletContainerCfgMode valueOf(String mode) {
if (mode == null) {
return null;
}
if (mode.equalsIgnoreCase(MODE_NONE.getMode())) {
return MODE_NONE;
}
if (mode.equalsIgnoreCase(MODE_MANUAL.getMode())) {
return MODE_MANUAL;
}
if (mode.equalsIgnoreCase(MODE_AUTO.getMode())) {
return MODE_AUTO;
}
return null;
}
/**
* Checks if this is the auto mode.<p>
*
* @return <code>true</code> if this is the auto mode
*/
public boolean isAuto() {
return this == MODE_AUTO;
}
/**
* Checks if this is the manual mode.<p>
*
* @return <code>true</code> if this is the manual mode
*/
public boolean isManual() {
return this == MODE_MANUAL;
}
/**
* Checks if this is the none mode.<p>
*
* @return <code>true</code> if this is the none mode
*/
public boolean isNone() {
return this == MODE_NONE;
}
}
/** String remote command execution return type. */
public static final CmsServletContainerCfgMode CFG_MODE_AUTO = CmsServletContainerCfgMode.MODE_AUTO;
/** Map remote command execution return type. */
public static final CmsServletContainerCfgMode CFG_MODE_MANUAL = CmsServletContainerCfgMode.MODE_MANUAL;
/** List remote command execution return type. */
public static final CmsServletContainerCfgMode CFG_MODE_NONE = CmsServletContainerCfgMode.MODE_NONE;
/** The static log object for this class. */
private static final Log LOG = CmsLog.getLog(CmsServletContainerSettings.class);
/** If the servlet can throw an exception if initialization fails, for instance, Weblogic and Resin have problems with the exception. */
private static boolean m_servletThrowsException = true;
/**
* The replacement request attribute for the {@link javax.servlet.http.HttpServletRequest#getPathInfo()} method,
* which is needed because this method is not properly implemented in BEA WLS 9.x.<p>
*/
private static final String REQUEST_ERROR_PAGE_ATTRIBUTE_WEBLOGIC = "weblogic.servlet.errorPage";
/** Constant name to identify GlassFish servers. */
// 2.1: "Sun GlassFish Enterprise Server v2.1"
private static final String SERVLET_CONTAINER_GLASSFISH = "GlassFish";
/** Constant name to identify Resin servers. */
private static final String SERVLET_CONTAINER_RESIN = "Resin";
/** Constant name to identify BEA WebLogic servers. */
private static final String SERVLET_CONTAINER_WEBLOGIC = "WebLogic Server";
/** Constant name to identify IBM Websphere servers. */
private static final String SERVLET_CONTAINER_WEBSPHERE = "IBM WebSphere Application Server";
/** The context path of the web application. */
private String m_contextPath;
/** The default web application (usually "ROOT"). */
private String m_defaultWebApplicationName;
/** The configuration mode. */
private CmsServletContainerCfgMode m_mode = CFG_MODE_NONE;
/** The OpenCms context and servlet path, e.g. <code>/opencms/opencms</code>. */
private String m_openCmsContext;
/** If the flex response has to prevent buffer flushing, for instance, Websphere does not allow to set headers afterwards, so we have to prevent it. */
private boolean m_preventResponseFlush;
/** If the tags need to be released after ending, this has to be prevented when running with Resin, for example. */
private boolean m_releaseTagsAfterEnd = true;
/**
* The request error page attribute to use if {@link javax.servlet.http.HttpServletRequest#getPathInfo()}
* is not working properly, like in BEA WLS 9.x.
*/
private String m_requestErrorPageAttribute;
/** The name of the servlet container running OpenCms. */
private String m_servletContainerName;
/** The servlet path for the OpenCms servlet. */
private String m_servletPath;
/** The web application name. */
private String m_webApplicationName;
/** The OpenCms web application servlet container folder path (in the "real" file system). */
private String m_webApplicationRfsPath;
/** The OpenCms web application "WEB-INF" path (in the "real" file system). */
private String m_webInfRfsPath;
/**
* Creates a new object.<p>
*
* @param context used to find out specifics of the servlet container
*/
public CmsServletContainerSettings(ServletContext context) {
// CmsSystemInfo<init> has to call this with null (for setup)
if (context != null) {
// check for OpenCms home (base) directory path
String webInfRfsPath = context.getInitParameter(OpenCmsServlet.SERVLET_PARAM_OPEN_CMS_HOME);
if (CmsStringUtil.isEmpty(webInfRfsPath)) {
webInfRfsPath = CmsFileUtil.searchWebInfFolder(context.getRealPath("/"));
if (CmsStringUtil.isEmpty(webInfRfsPath)) {
throw new CmsInitException(Messages.get().container(Messages.ERR_CRITICAL_INIT_FOLDER_0));
}
}
// set the default web application name
// read the the default name from the servlet context parameters
String defaultWebApplication = context.getInitParameter("DefaultWebApplication");
// read the the OpenCms servlet mapping from the servlet context parameters
String servletMapping = context.getInitParameter(OpenCmsServlet.SERVLET_PARAM_OPEN_CMS_SERVLET);
if (servletMapping == null) {
throw new CmsInitException(Messages.get().container(Messages.ERR_CRITICAL_INIT_SERVLET_0));
}
// read the servlet container name
String servletContainerName = context.getServerInfo();
// web application context:
// read it from the servlet context parameters
// this is needed in case an application server specific deployment descriptor is used to changed the webapp context
String webApplicationContext = context.getInitParameter(OpenCmsServlet.SERVLET_PARAM_WEB_APPLICATION_CONTEXT);
if (CmsStringUtil.isEmptyOrWhitespaceOnly(webApplicationContext)) {
try {
URL contextRelativeUrl = context.getResource("/");
webApplicationContext = contextRelativeUrl.getPath();
String[] pathTokens = CmsStringUtil.splitAsArray(webApplicationContext, '/');
if (pathTokens.length == 1) {
/*
* There may be a "" context configured (e.g. in GlassFish).
*/
webApplicationContext = "";
} else {
webApplicationContext = pathTokens[pathTokens.length - 1];
}
} catch (MalformedURLException e) {
LOG.error(Messages.get().getBundle().key(Messages.LOG_INIT_CONTEXTNAME_0), e);
}
}
// init values:
init(webInfRfsPath, defaultWebApplication, servletMapping, servletContainerName, webApplicationContext);
// finally care for the speciality of different servlet containers:
initContainerSpecifics(context);
}
}
/**
* Creates an instance based on the given values.<p>
*
* This is intended for <code>{@link CmsShell}</code> access.<p>
*
* @param webInfRfsPath the OpenCms web application "WEB-INF" path in the "real" file system) to set
* @param servletMapping the OpenCms servlet mapping (e.g. "/opencms/*")
* @param webApplicationContext the name/path of the OpenCms web application context (optional, will be calculated form the path if null)
* @param defaultWebApplication the default web application name (usually "ROOT")
* @param servletContainerName the name of the servlet container running OpenCms
*/
protected CmsServletContainerSettings(
String webInfRfsPath,
String defaultWebApplication,
String servletMapping,
String servletContainerName,
String webApplicationContext) {
init(webInfRfsPath, defaultWebApplication, servletMapping, servletContainerName, webApplicationContext);
}
/**
* Checks if the servlet can throw an exception if initialization fails.<p>
*
* @return <code>true</code> if the servlet can throw an exception if initialization fails
*/
public static boolean isServletThrowsException() {
return m_servletThrowsException;
}
/**
* Returns the web application context path, e.g. "" (empty String) if the web application
* is the default web application (usually "ROOT"), or "/opencms" if the web application
* is called "opencms".<p>
*
* <i>From the Java Servlet Specification v2.4:</i><br>
* <b>Context Path:</b> The path prefix associated with the ServletContext that this
* servlet is a part of. If this context is the "default" context rooted at the base of
* the web server's URL name space, this path will be an empty string. Otherwise,
* if the context is not rooted at the root of the server's name space, the path starts
* with a "/" character but does not end with a "/" character.<p>
*
* @return the web application context path
* @see #getWebApplicationName()
* @see #getServletPath()
* @see #getOpenCmsContext()
*/
public String getContextPath() {
return m_contextPath;
}
/**
* Returns the default web application name (usually "ROOT").<p>
*
* @return the default web application name
*/
public String getDefaultWebApplicationName() {
return m_defaultWebApplicationName;
}
/**
* Returns the mode.<p>
*
* @return the mode
*/
public CmsServletContainerCfgMode getMode() {
return m_mode;
}
/**
* Returns the OpenCms request context, e.g. "/opencms/opencms".<p>
*
* The OpenCms context will always start with a "/" and never have a trailing "/".
* The OpenCms context is identical to <code>getContexPath() + getServletPath()</code>.<p>
*
* @return the OpenCms request context, e.g. "/opencms/opencms"
* @see #getContextPath()
* @see #getServletPath()
*/
public String getOpenCmsContext() {
return m_openCmsContext;
}
/**
* Returns the request error page attribute.<p>
*
* @return the request error page attribute
*/
public String getRequestErrorPageAttribute() {
return m_requestErrorPageAttribute;
}
/**
* Returns the name of the servlet container running OpenCms.<p>
*
* @return the name of the servlet container running OpenCms
*/
public String getServletContainerName() {
return m_servletContainerName;
}
/**
* Returns the OpenCms servlet path, e.g. "/opencms".<p>
*
* <i>From the Java Servlet Specification v2.4:</i><br>
* <b>Servlet Path:</b> The path section that directly corresponds to the mapping
* which activated this request. This path starts with a?/? character except in the
* case where the request is matched with the ?/*? pattern, in which case it is the
* empty string.<p>
*
* @return the OpenCms servlet path
* @see #getContextPath()
* @see #getWebApplicationName()
* @see #getOpenCmsContext()
*/
public String getServletPath() {
return m_servletPath;
}
/**
* Returns the OpenCms web application name, e.g. "opencms" or "ROOT" (no leading or trailing "/").<p>
*
* The web application name is stored for informational purposes only.
* If you want to construct an URI, use either {@link #getContextPath()} and
* {@link #getServletPath()}, or for links to the OpenCms VFS use {@link #getOpenCmsContext()}.<p>
*
* @return the OpenCms web application name
* @see #getContextPath()
* @see #getServletPath()
* @see #getOpenCmsContext()
*/
public String getWebApplicationName() {
return m_webApplicationName;
}
/**
* Returns the OpenCms web application folder in the servlet container.<p>
*
* @return the OpenCms web application folder in the servlet container
*/
public String getWebApplicationRfsPath() {
return m_webApplicationRfsPath;
}
/**
* Returns the OpenCms web application "WEB-INF" directory path.<p>
*
* @return the OpenCms web application "WEB-INF" directory path
*/
public String getWebInfRfsPath() {
return m_webInfRfsPath;
}
/**
* Checks if the flex response has to prevent buffer flushing.<p>
*
* @return <code>true</code> if the flex response has to prevent buffer flushing
*/
public boolean isPreventResponseFlush() {
return m_preventResponseFlush;
}
/**
* Checks if the tags need to be released after ending.<p>
*
* @return <code>true</code> if the tags need to be released after ending
*/
public boolean isReleaseTagsAfterEnd() {
return m_releaseTagsAfterEnd;
}
/**
* Sets the mode from the configuration.<p>
*
* @param configValue the mode to set
*/
public void setMode(String configValue) {
m_mode = CmsServletContainerCfgMode.valueOf(configValue);
}
/**
* Sets if the flex response has to prevent buffer flushing.<p>
*
* @param preventResponseFlush the flag to set
*/
public void setPreventResponseFlush(boolean preventResponseFlush) {
m_preventResponseFlush = preventResponseFlush;
}
/**
* Sets if the tags need to be released after ending.<p>
*
* @param releaseTagsAfterEnd the flag to set
*/
public void setReleaseTagsAfterEnd(boolean releaseTagsAfterEnd) {
m_releaseTagsAfterEnd = releaseTagsAfterEnd;
}
/**
* Sets the request error page attribute.<p>
*
* @param requestErrorPageAttribute the request error page attribute to set
*/
public void setRequestErrorPageAttribute(String requestErrorPageAttribute) {
m_requestErrorPageAttribute = requestErrorPageAttribute;
}
/**
* Sets if the servlet can throw an exception if initialization fails.<p>
*
* @param servletThrowsException the flag to set
*/
public void setServletThrowsException(boolean servletThrowsException) {
m_servletThrowsException = servletThrowsException;
}
/**
* Initialization code common to both constructors.<p>
*
* While the "webapplication - mode" constructor obtains all values from the
* <code>{@link ServletContext}</code> the <code>{@link CmsShell}</code> constructor
* accepts them as arguments and passes them here. <p>
*
* @param webInfRfsPath the OpenCms web application "WEB-INF" path in the "real" file system) to set
* @param servletMapping the OpenCms servlet mapping (e.g. "/opencms/*")
* @param webApplicationContext the name/path of the OpenCms web application context (optional, will be calculated form the path if null)
* @param defaultWebApplication the default web application name (usually "ROOT")
* @param servletContainerName the name of the servlet container running OpenCms
*/
private void init(
String webInfRfsPath,
String defaultWebApplication,
String servletMapping,
String servletContainerName,
String webApplicationContext) {
// WEB-INF RFS path
webInfRfsPath = webInfRfsPath.replace('\\', '/');
if (!webInfRfsPath.endsWith("/")) {
webInfRfsPath = webInfRfsPath + "/";
}
m_webInfRfsPath = CmsFileUtil.normalizePath(webInfRfsPath);
// default web application
if (defaultWebApplication == null) {
defaultWebApplication = "";
}
if (defaultWebApplication.endsWith("/")) {
defaultWebApplication = defaultWebApplication.substring(0, defaultWebApplication.length() - 1);
}
if (defaultWebApplication.startsWith("/")) {
defaultWebApplication = defaultWebApplication.substring(1);
}
m_defaultWebApplicationName = defaultWebApplication;
// servlet mapping
if (!servletMapping.startsWith("/")) {
servletMapping = "/" + servletMapping;
}
if (servletMapping.endsWith("/*")) {
// usually a mapping must be in the form "/opencms/*", cut off all slashes
servletMapping = servletMapping.substring(0, servletMapping.length() - 2);
}
m_servletPath = servletMapping;
// servlet container name
if (servletContainerName == null) {
m_servletContainerName = "";
}
m_servletContainerName = servletContainerName;
// set the web application name
File path = new File(m_webInfRfsPath);
m_webApplicationName = path.getParentFile().getName();
String contextPath = webApplicationContext;
// whitespace is OK because e.g. on glassfish the "" context may be configured
if (contextPath == null) {
contextPath = m_webApplicationName;
// this fixes an issue with context names in JBoss
if (contextPath.endsWith(".war")) {
contextPath = contextPath.substring(0, contextPath.length() - 4);
}
}
// set the context path
if (contextPath.equals(getDefaultWebApplicationName()) || "".equals(contextPath)) {
m_contextPath = "";
} else {
m_contextPath = "/" + contextPath;
}
// set the OpenCms context
m_openCmsContext = m_contextPath + m_servletPath;
// set the web application rfs path
m_webApplicationRfsPath = path.getParentFile().getAbsolutePath();
if (!m_webApplicationRfsPath.endsWith(File.separator)) {
m_webApplicationRfsPath += File.separator;
}
// fill some defaults:
m_releaseTagsAfterEnd = false;
m_requestErrorPageAttribute = null;
m_servletThrowsException = true;
m_preventResponseFlush = false;
}
/**
* Initializes these container settings with container specific settings.<p>
*
* @param context
* the servlet context to find out information about the servlet container
*/
private void initContainerSpecifics(ServletContext context) {
// the tags behavior
m_releaseTagsAfterEnd = !(m_servletContainerName.indexOf(SERVLET_CONTAINER_RESIN) > -1);
// the request error page attribute
if (m_servletContainerName.indexOf(SERVLET_CONTAINER_WEBLOGIC) > -1) {
m_requestErrorPageAttribute = REQUEST_ERROR_PAGE_ATTRIBUTE_WEBLOGIC;
}
// the failed initialization behavior
m_servletThrowsException = true;
m_servletThrowsException &= (m_servletContainerName.indexOf(SERVLET_CONTAINER_RESIN) < 0);
m_servletThrowsException &= (m_servletContainerName.indexOf(SERVLET_CONTAINER_WEBLOGIC) < 0);
m_servletThrowsException &= (m_servletContainerName.indexOf(SERVLET_CONTAINER_GLASSFISH) < 0);
// the flush flex response behavior
m_preventResponseFlush = false;
m_preventResponseFlush |= (m_servletContainerName.indexOf(SERVLET_CONTAINER_WEBSPHERE) > -1);
m_preventResponseFlush |= (m_servletContainerName.indexOf(SERVLET_CONTAINER_RESIN) > -1);
}
}