org.enhydra.xml.xmlc.servlet.XMLCContextInit Maven / Gradle / Ivy
The newest version!
/*
* Enhydra Java Application Server Project
*
* The contents of this file are subject to the Enhydra Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License on
* the Enhydra web site ( http://www.enhydra.org/ ).
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific terms governing rights and limitations
* under the License.
*
* The Initial Developer of the Enhydra Application Server is Lutris
* Technologies, Inc. The Enhydra Application Server and portions created
* by Lutris Technologies, Inc. are Copyright Lutris Technologies, Inc.
* All Rights Reserved.
*
* Contributor(s):
*
* $Id: XMLCContextInit.java,v 1.4 2005/10/22 05:42:36 jkjome Exp $
*/
package org.enhydra.xml.xmlc.servlet;
import java.io.File;
import java.lang.reflect.Constructor;
import java.util.StringTokenizer;
import javax.servlet.ServletContext;
import org.enhydra.xml.xmlc.XMLCError;
import org.enhydra.xml.xmlc.XMLCFactory;
import org.enhydra.xml.xmlc.XMLCLogger;
import org.enhydra.xml.xmlc.XMLCStdFactory;
import org.enhydra.xml.xmlc.deferredparsing.DocumentLoader;
import org.enhydra.xml.xmlc.deferredparsing.XMLCDeferredParsingFactory;
/**
* Create a new XMLCContext from init parameters.
*/
final class XMLCContextInit {
/** Signature declaration for the XMLCLogger constructor */
private static final Class[] LOGGER_CONSTRUCTOR_SIGNATURE = new Class[] {
ServletContext.class, Boolean.TYPE, Boolean.TYPE };
/** Signature declaration for the XMLCContext constructor */
private static final Class[] CONTEXT_CONSTRUCTOR_SIGNATURE = new Class[] {
ServletContext.class, XMLCFactory.class,
XMLCContext.SessionURLEncodingMode.class,
Boolean.TYPE, Integer.TYPE
};
/**
* Definition of xmlcReloading parameter.
*/
private static final String PARAM_XMLC_RELOADING = "xmlcReloading";
private static final String PARAM_XMLC_RELOADING_OFF = "off";
private static final String PARAM_XMLC_RELOADING_RELOAD = "reload";
private static final String PARAM_XMLC_RELOADING_RECOMPILE = "recompile";
private static final String PARAM_XMLC_DEFERRED_PARSING = "reparse";
/**
* Definition of xmlcReparseResourceDirs parameter
*/
private static final String PARAM_XMLC_REPARSE_RESOURCE_DIRS = "xmlcReparseResourceDirs";
/**
* Definition of xmlcReparsePackagePrefixes parameter
*/
private static final String PARAM_XMLC_REPARSE_PACKAGE_PREFIXES = "xmlcReparsePackagePrefixes";
/**
* Definition of xmlcReparseDefaultMetaDataPath poarameter
*/
private static final String PARAM_XMLC_REPARSE_DEFAULT_METADATA_PATH = "xmlcReparseDefaultMetaDataPath";
/**
* Definition of xmlcRecompilationHandler parameter.
*/
private static final String PARAM_XMLC_RECOMP_HANDLER = "xmlcRecompilationHandler";
/**
* Definition of xmlcLogger parameter.
*/
private static final String PARAM_XMLC_LOGGER = "xmlcLogger";
/**
* Definition of xmlcLogging parameter.
*/
private static final String PARAM_XMLC_LOGGING = "xmlcLogging";
private static final String PARAM_XMLC_LOGGING_INFO = "INFO";
private static final String PARAM_XMLC_LOGGING_DEBUG = "DEBUG";
private static final String PARAM_XMLC_LOGGING_STATS = "STATS";
/**
* Definition of xmlcCompression parameter.
*/
private static final String PARAM_XMLC_COMPRESS = "xmlcCompression";
private static final String PARAM_XMLC_COMPRESS_NONE = "none";
private static final String PARAM_XMLC_COMPRESS_GZIP = "gzip";
/**
* Definition of xmlcLogging parameter values as a bit set.
*/
private static final int XMLC_LOG_INFO = 0x01;
private static final int XMLC_LOG_DEBUG = 0x02;
private static final int XMLC_LOG_STATS = 0x04;
/**
* Definition of xmlcContextImpl parameter.
*/
private static final String PARAM_XMLC_CONTEXT_IMPL = "xmlcContextImpl";
/**
* Definition of xmlcSessionURLEncoding parameter.
*/
private static final String PARAM_XMLC_SESSION_URL_ENCODING
= "xmlcSessionURLEncoding";
/**
* Parse the xmlcReloading parameter.
* @return The string constant defined in this class (refs can be
* compared).
*/
private String parseReloadingParam(ServletContext servletContext) {
String value = servletContext.getInitParameter(PARAM_XMLC_RELOADING);
if (value == null) {
return PARAM_XMLC_RELOADING_OFF; // default
} else if (value.equals(PARAM_XMLC_RELOADING_OFF)) {
return PARAM_XMLC_RELOADING_OFF;
} else if (value.equals(PARAM_XMLC_RELOADING_RELOAD)) {
return PARAM_XMLC_RELOADING_RELOAD;
} else if (value.equals(PARAM_XMLC_RELOADING_RECOMPILE)) {
return PARAM_XMLC_RELOADING_RECOMPILE;
} else if (value.equals(PARAM_XMLC_DEFERRED_PARSING)) {
return PARAM_XMLC_DEFERRED_PARSING;
} else {
throw new XMLCError("Invalid value for " + PARAM_XMLC_RELOADING
+ " servlet parameter: \""
+ value + "\"; expected one of " +
PARAM_XMLC_RELOADING_OFF + ", " +
PARAM_XMLC_RELOADING_RELOAD + ", " +
PARAM_XMLC_RELOADING_RECOMPILE + ", or " +
PARAM_XMLC_DEFERRED_PARSING);
}
}
/**
* Parse one of the tokens from the logging config parameter.
*/
private int parseLoggingToken(String token) {
if (token.equals(PARAM_XMLC_LOGGING_INFO)) {
return XMLC_LOG_INFO;
} else if (token.equals(PARAM_XMLC_LOGGING_DEBUG)) {
return XMLC_LOG_DEBUG;
} else if (token.equals(PARAM_XMLC_LOGGING_STATS)) {
return XMLC_LOG_STATS;
} else {
throw new XMLCError("Invalid value for argument to "
+ PARAM_XMLC_LOGGING
+ " servlet parameter: \""
+ token + "\"; expected one of " +
PARAM_XMLC_LOGGING_INFO + ", " +
PARAM_XMLC_LOGGING_DEBUG + ", or " +
PARAM_XMLC_LOGGING_STATS);
}
}
/**
* Parse the xmlcLogging parameter.
* @return Bit set representing the logging flags.
*/
private int parseLoggingParam(ServletContext servletContext) {
String value = servletContext.getInitParameter(PARAM_XMLC_LOGGING);
if (value == null) {
return XMLC_LOG_INFO; // default
}
// Parse the string.
StringTokenizer tokens = new StringTokenizer(value, " ,");
int flags = 0;
while (tokens.hasMoreTokens()) {
flags |= parseLoggingToken(tokens.nextToken());
}
return flags;
}
/**
* Parse the xmlcCompression parameter.
* @return Bit set representing the compression flags.
*/
private int parseCompressionParam(ServletContext servletContext) {
String value = servletContext.getInitParameter(PARAM_XMLC_COMPRESS);
if (value == null) {
return XMLCContext.XMLC_COMPRESS_NONE; // default
} else if (value.equals(PARAM_XMLC_COMPRESS_NONE)) {
return XMLCContext.XMLC_COMPRESS_NONE;
} else if (value.equals(PARAM_XMLC_COMPRESS_GZIP)) {
return XMLCContext.XMLC_COMPRESS_GZIP;
} else {
return XMLCContext.XMLC_COMPRESS_NONE; // default
}
}
/**
* Parse the PARAM_XMLC_SESSION_URL_ENCODING parameter.
* @return The object constant defining the encoding mode
*/
private XMLCContext.SessionURLEncodingMode parseSessionURLEncodingParam(ServletContext servletContext) {
String value = servletContext.getInitParameter(PARAM_XMLC_SESSION_URL_ENCODING);
if (value == null) {
return XMLCContext.URL_ENCODING_AUTO; // default
} else if (value.equals(XMLCContext.URL_ENCODING_AUTO.toString())) {
return XMLCContext.URL_ENCODING_AUTO;
} else if (value.equals(XMLCContext.URL_ENCODING_ALWAYS.toString())) {
return XMLCContext.URL_ENCODING_ALWAYS;
} else if (value.equals(XMLCContext.URL_ENCODING_NEVER.toString())) {
return XMLCContext.URL_ENCODING_NEVER;
} else {
throw new XMLCError("Invalid value for " + PARAM_XMLC_RELOADING
+ " servlet parameter: \""
+ value + "\"; expected one of " +
XMLCContext.URL_ENCODING_AUTO + ", " +
XMLCContext.URL_ENCODING_ALWAYS + ", or " +
XMLCContext.URL_ENCODING_NEVER);
}
}
/**
* Create the XMLCFactory.
*/
private XMLCFactory createFactory(String reloadingMode,
ServletContext servletContext,
XMLCLogger logger) {
if (reloadingMode == PARAM_XMLC_RELOADING_OFF) {
return new XMLCStdFactory(Thread.currentThread().getContextClassLoader(), logger);
} else if (reloadingMode == PARAM_XMLC_DEFERRED_PARSING) {
DocumentLoader loader = null;
String loaderName = servletContext.getInitParameter(PARAM_XMLC_RECOMP_HANDLER);
if (loaderName!=null) {
try {
loader = (DocumentLoader)Class.forName(loaderName, true, Thread.currentThread().getContextClassLoader()).newInstance();
} catch (Throwable t) {
throw new XMLCError("Cannot create custom document " +
"loader of type \"" +
loaderName + "\"", t);
}
// If we have a servlet aware document
// loader, pass it the servlet context.
if (loader instanceof ServletDocumentLoader) {
((ServletDocumentLoader)loader)
.setServletContext(servletContext);
}
}
XMLCDeferredParsingFactory newFactory
= new XMLCDeferredParsingFactory(loader,
Thread.currentThread().getContextClassLoader(),
logger);
String resDirs = servletContext.getInitParameter(PARAM_XMLC_REPARSE_RESOURCE_DIRS);
if (resDirs != null) {
StringTokenizer st = new StringTokenizer (resDirs, File.pathSeparator);
while (st.hasMoreTokens()) {
newFactory.addResourceDir(st.nextToken());
}
}
String pkgPredixes = servletContext.getInitParameter(PARAM_XMLC_REPARSE_PACKAGE_PREFIXES);
if (pkgPredixes != null) {
StringTokenizer st = new StringTokenizer (pkgPredixes, File.pathSeparator);
while (st.hasMoreTokens()) {
newFactory.addPackagePrefix(st.nextToken());
}
}
String defaultMetaDataPath = servletContext.getInitParameter(PARAM_XMLC_REPARSE_DEFAULT_METADATA_PATH);
if (defaultMetaDataPath != null) {
newFactory.setDefaultMetaDataPath(defaultMetaDataPath);
}
return newFactory;
} else {
throw new XMLCError("Unknown reloading mode: " + reloadingMode);
}
}
/**
* Create a new context.
*/
XMLCContext createContext(ServletContext servletContext) {
String reloadingMode = parseReloadingParam(servletContext);
int loggingFlags = parseLoggingParam(servletContext);
XMLCContext.SessionURLEncodingMode sessionURLEncodingMode
= parseSessionURLEncodingParam(servletContext);
String loggerName = servletContext.getInitParameter(PARAM_XMLC_LOGGER);
XMLCLogger logger = null;
if (loggerName != null) {
try {
Class loggerClass = Class.forName(loggerName, true, Thread.currentThread().getContextClassLoader());
Constructor c =
loggerClass.getConstructor(LOGGER_CONSTRUCTOR_SIGNATURE);
logger = (XMLCLogger)c.newInstance(new Object[] {
servletContext,
new Boolean((loggingFlags & XMLC_LOG_INFO) != 0),
new Boolean((loggingFlags & XMLC_LOG_DEBUG) != 0)});
} catch (Throwable t) {
throw new XMLCError("Cannot create custom logger of type \"" +
loggerName + "\"", t);
}
}
if (logger == null) {
logger = new ServletXMLCLogger(servletContext,
((loggingFlags & XMLC_LOG_INFO) != 0),
((loggingFlags & XMLC_LOG_DEBUG) != 0));
}
XMLCFactory factory = createFactory(reloadingMode, servletContext, logger);
int compressionType = parseCompressionParam(servletContext);
String contextImplName =
servletContext.getInitParameter(PARAM_XMLC_CONTEXT_IMPL);
if (contextImplName != null) {
try {
Class contextImplClass = Class.forName(contextImplName, true, Thread.currentThread().getContextClassLoader());
Constructor c =
contextImplClass.getConstructor(
CONTEXT_CONSTRUCTOR_SIGNATURE);
return (XMLCContext)c.newInstance(new Object[] {
servletContext, factory, sessionURLEncodingMode,
new Boolean((loggingFlags & XMLC_LOG_STATS) != 0),
new Integer(compressionType) });
} catch (Throwable t) {
throw new XMLCError(
"Cannot create custom XMLC context of type \"" +
contextImplName + "\"", t);
}
} else {
return new
XMLCContext(servletContext, factory, sessionURLEncodingMode,
((loggingFlags & XMLC_LOG_STATS) != 0),
compressionType);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy