Java tutorial
/* * 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.loader; import org.opencms.configuration.CmsConfigurationException; import org.opencms.configuration.CmsVfsConfiguration; import org.opencms.file.CmsObject; import org.opencms.file.CmsResource; import org.opencms.file.CmsResourceFilter; import org.opencms.file.collectors.I_CmsResourceCollector; import org.opencms.file.types.CmsResourceTypeBinary; import org.opencms.file.types.CmsResourceTypeFolder; import org.opencms.file.types.CmsResourceTypePlain; import org.opencms.file.types.CmsResourceTypeUnknownFile; import org.opencms.file.types.CmsResourceTypeUnknownFolder; import org.opencms.file.types.I_CmsResourceType; import org.opencms.main.CmsException; import org.opencms.main.CmsLog; import org.opencms.main.OpenCms; import org.opencms.module.CmsModule; import org.opencms.module.CmsModuleManager; import org.opencms.relations.CmsRelationType; import org.opencms.security.CmsRole; import org.opencms.security.CmsRoleViolationException; import org.opencms.util.CmsHtmlConverter; import org.opencms.util.CmsHtmlConverterJTidy; import org.opencms.util.CmsHtmlConverterOption; import org.opencms.util.CmsResourceTranslator; import org.opencms.util.CmsStringUtil; import org.opencms.util.I_CmsHtmlConverter; import org.opencms.workplace.CmsWorkplace; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Properties; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; /** * Collects all available resource loaders, resource types and resource collectors at startup and provides * methods to access them during OpenCms runtime.<p> * * @since 6.0.0 */ public class CmsResourceManager { /** * Contains the part of the resource manager configuration that can be changed * during runtime by the import / deletion of a module.<p> * * A module can add resource types and extension mappings to resource types.<p> */ static final class CmsResourceManagerConfiguration { /** The mappings of file extensions to resource types. */ protected Map<String, String> m_extensionMappings; /** A list that contains all initialized resource types. */ protected List<I_CmsResourceType> m_resourceTypeList; /** A list that contains all initialized resource types, plus configured types for "unknown" resources. */ protected List<I_CmsResourceType> m_resourceTypeListWithUnknown; /** A map that contains all initialized resource types mapped to their type id. */ private Map<Integer, I_CmsResourceType> m_resourceTypeIdMap; /** A map that contains all initialized resource types mapped to their type name. */ private Map<String, I_CmsResourceType> m_resourceTypeNameMap; /** * Creates a new resource manager data storage.<p> */ protected CmsResourceManagerConfiguration() { m_resourceTypeIdMap = new HashMap<Integer, I_CmsResourceType>(128); m_resourceTypeNameMap = new HashMap<String, I_CmsResourceType>(128); m_extensionMappings = new HashMap<String, String>(128); m_resourceTypeList = new ArrayList<I_CmsResourceType>(32); } /** * Adds a resource type to the list of configured resource types.<p> * * @param type the resource type to add */ protected void addResourceType(I_CmsResourceType type) { m_resourceTypeIdMap.put(Integer.valueOf(type.getTypeId()), type); m_resourceTypeNameMap.put(type.getTypeName(), type); m_resourceTypeList.add(type); } /** * Freezes the current configuration by making all data structures unmodifiable * that can be accessed form outside this class.<p> * * @param restypeUnknownFolder the configured default resource type for unknown folders * @param restypeUnknownFile the configured default resource type for unknown files */ protected void freeze(I_CmsResourceType restypeUnknownFolder, I_CmsResourceType restypeUnknownFile) { // generate the resource type list with unknown resource types m_resourceTypeListWithUnknown = new ArrayList<I_CmsResourceType>(m_resourceTypeList.size() + 2); if (restypeUnknownFolder != null) { m_resourceTypeListWithUnknown.add(restypeUnknownFolder); } if (restypeUnknownFile != null) { m_resourceTypeListWithUnknown.add(restypeUnknownFile); } m_resourceTypeListWithUnknown.addAll(m_resourceTypeList); // freeze the current configuration m_resourceTypeListWithUnknown = Collections.unmodifiableList(m_resourceTypeListWithUnknown); m_resourceTypeList = Collections.unmodifiableList(m_resourceTypeList); m_extensionMappings = Collections.unmodifiableMap(m_extensionMappings); } /** * Returns the configured resource type with the matching type id, or <code>null</code> * if a resource type with that id is not configured.<p> * * @param typeId the type id to get the resource type for * * @return the configured resource type with the matching type id, or <code>null</code> */ protected I_CmsResourceType getResourceTypeById(int typeId) { return m_resourceTypeIdMap.get(Integer.valueOf(typeId)); } /** * Returns the configured resource type with the matching type name, or <code>null</code> * if a resource type with that name is not configured.<p> * * @param typeName the type name to get the resource type for * * @return the configured resource type with the matching type name, or <code>null</code> */ protected I_CmsResourceType getResourceTypeByName(String typeName) { return m_resourceTypeNameMap.get(typeName); } } /** The path to the default template. */ public static final String DEFAULT_TEMPLATE = CmsWorkplace.VFS_PATH_COMMONS + "template/default.jsp"; /** The MIME type <code>"text/html"</code>. */ public static final String MIMETYPE_HTML = "text/html"; /** The MIME type <code>"text/plain"</code>. */ public static final String MIMETYPE_TEXT = "text/plain"; /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsResourceManager.class); /** The map for all configured collector names, mapped to their collector class. */ private Map<String, I_CmsResourceCollector> m_collectorNameMappings; /** The list of all currently configured content collector instances. */ private List<I_CmsResourceCollector> m_collectors; /** The current resource manager configuration. */ private CmsResourceManagerConfiguration m_configuration; /** The list of all configured HTML converters. */ private List<CmsHtmlConverterOption> m_configuredHtmlConverters; /** The list of all configured MIME types. */ private List<CmsMimeType> m_configuredMimeTypes; /** The list of all configured relation types. */ private List<CmsRelationType> m_configuredRelationTypes; /** Filename translator, used only for the creation of new files. */ private CmsResourceTranslator m_fileTranslator; /** Folder translator, used to translate all accesses to resources. */ private CmsResourceTranslator m_folderTranslator; /** Indicates if the configuration is finalized (frozen). */ private boolean m_frozen; /** The OpenCms map of configured HTML converters. */ private Map<String, String> m_htmlConverters; /** A list that contains all initialized resource loaders. */ private List<I_CmsResourceLoader> m_loaderList; /** All initialized resource loaders, mapped to their id. */ private I_CmsResourceLoader[] m_loaders; /** The OpenCms map of configured MIME types. */ private Map<String, String> m_mimeTypes; /** The URL name generator for XML contents. */ private I_CmsFileNameGenerator m_nameGenerator; /** A list that contains all resource types added from the XML configuration. */ private List<I_CmsResourceType> m_resourceTypesFromXml; /** The configured default type for files when the resource type is missing. */ private I_CmsResourceType m_restypeUnknownFile; /** The configured default type for folders when the resource type is missing. */ private I_CmsResourceType m_restypeUnknownFolder; /** XSD translator, used to translate all accesses to XML schemas from Strings. */ private CmsResourceTranslator m_xsdTranslator; /** * Creates a new instance for the resource manager, * will be called by the VFS configuration manager.<p> */ public CmsResourceManager() { if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_STARTING_LOADER_CONFIG_0)); } m_resourceTypesFromXml = new ArrayList<I_CmsResourceType>(); m_loaders = new I_CmsResourceLoader[16]; m_loaderList = new ArrayList<I_CmsResourceLoader>(); m_configuredMimeTypes = new ArrayList<CmsMimeType>(); m_configuredRelationTypes = new ArrayList<CmsRelationType>(); m_configuredHtmlConverters = new ArrayList<CmsHtmlConverterOption>(); } /** * Adds a given content collector class to the type manager.<p> * * @param className the name of the class to add * @param order the order number for this collector * * @return the created content collector instance * * @throws CmsConfigurationException in case the collector could not be properly initialized */ public synchronized I_CmsResourceCollector addContentCollector(String className, String order) throws CmsConfigurationException { Class<?> classClazz; // init class for content collector try { classClazz = Class.forName(className); } catch (ClassNotFoundException e) { LOG.error(Messages.get().getBundle().key(Messages.LOG_CONTENT_COLLECTOR_CLASS_NOT_FOUND_1, className), e); return null; } I_CmsResourceCollector collector; try { collector = (I_CmsResourceCollector) classClazz.newInstance(); } catch (InstantiationException e) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_INVALID_COLLECTOR_NAME_1, className)); } catch (IllegalAccessException e) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_INVALID_COLLECTOR_NAME_1, className)); } catch (ClassCastException e) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_INVALID_COLLECTOR_NAME_1, className)); } // set the configured order for the collector int ord = 0; try { ord = Integer.valueOf(order).intValue(); } catch (NumberFormatException e) { LOG.error(Messages.get().getBundle().key(Messages.LOG_COLLECTOR_BAD_ORDER_NUMBER_1, className), e); } collector.setOrder(ord); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ADD_COLLECTOR_CLASS_2, className, order)); } // extend or init the current list of configured collectors if (m_collectors != null) { m_collectors = new ArrayList<I_CmsResourceCollector>(m_collectors); m_collectorNameMappings = new HashMap<String, I_CmsResourceCollector>(m_collectorNameMappings); } else { m_collectors = new ArrayList<I_CmsResourceCollector>(); m_collectorNameMappings = new HashMap<String, I_CmsResourceCollector>(); } if (!m_collectors.contains(collector)) { // this is a collector not currently configured m_collectors.add(collector); Iterator<String> i = collector.getCollectorNames().iterator(); while (i.hasNext()) { String name = i.next(); if (m_collectorNameMappings.containsKey(name)) { // this name is already configured, check the order of the collector I_CmsResourceCollector otherCollector = m_collectorNameMappings.get(name); if (collector.getOrder() > otherCollector.getOrder()) { // new collector has a greater order than the old collector in the Map m_collectorNameMappings.put(name, collector); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT .info(Messages.get().getBundle().key(Messages.INIT_COLLECTOR_REPLACED_1, name)); } } else { if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle() .key(Messages.INIT_DUPLICATE_COLLECTOR_SKIPPED_1, name)); } } } else { m_collectorNameMappings.put(name, collector); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ADD_COLLECTOR_1, name)); } } } } // ensure list is unmodifiable to avoid potential misuse or accidental changes Collections.sort(m_collectors); m_collectors = Collections.unmodifiableList(m_collectors); m_collectorNameMappings = Collections.unmodifiableMap(m_collectorNameMappings); // return the created collector instance return collector; } /** * Adds a new HTML converter class to internal list of loaded converter classes.<p> * * @param name the name of the option that should trigger the HTML converter class * @param className the name of the class to add * * @return the created HTML converter instance * * @throws CmsConfigurationException in case the HTML converter could not be properly initialized */ public I_CmsHtmlConverter addHtmlConverter(String name, String className) throws CmsConfigurationException { // check if new conversion option can still be added if (m_frozen) { throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0)); } Class<?> classClazz; // init class for content converter try { classClazz = Class.forName(className); } catch (ClassNotFoundException e) { LOG.error(Messages.get().getBundle().key(Messages.LOG_HTML_CONVERTER_CLASS_NOT_FOUND_1, className), e); return null; } I_CmsHtmlConverter converter; try { converter = (I_CmsHtmlConverter) classClazz.newInstance(); } catch (InstantiationException e) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_INVALID_HTMLCONVERTER_NAME_1, className)); } catch (IllegalAccessException e) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_INVALID_HTMLCONVERTER_NAME_1, className)); } catch (ClassCastException e) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_INVALID_HTMLCONVERTER_NAME_1, className)); } if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info( Messages.get().getBundle().key(Messages.INIT_ADD_HTML_CONVERTER_CLASS_2, className, name)); } m_configuredHtmlConverters.add(new CmsHtmlConverterOption(name, className)); return converter; } /** * Adds a new loader to the internal list of loaded loaders.<p> * * @param loader the loader to add * @throws CmsConfigurationException in case the resource manager configuration is already initialized */ public void addLoader(I_CmsResourceLoader loader) throws CmsConfigurationException { // check if new loaders can still be added if (m_frozen) { throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0)); } // add the loader to the internal list of loaders int pos = loader.getLoaderId(); if (pos >= m_loaders.length) { I_CmsResourceLoader[] buffer = new I_CmsResourceLoader[pos * 2]; System.arraycopy(m_loaders, 0, buffer, 0, m_loaders.length); m_loaders = buffer; } m_loaders[pos] = loader; m_loaderList.add(loader); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ADD_LOADER_2, loader.getClass().getName(), new Integer(pos))); } } /** * Adds a new MIME type from the XML configuration to the internal list of MIME types.<p> * * @param extension the MIME type extension * @param type the MIME type description * * @return the created MIME type instance * * @throws CmsConfigurationException in case the resource manager configuration is already initialized */ public CmsMimeType addMimeType(String extension, String type) throws CmsConfigurationException { // check if new mime types can still be added if (m_frozen) { throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0)); } CmsMimeType mimeType = new CmsMimeType(extension, type); m_configuredMimeTypes.add(mimeType); return mimeType; } /** * Adds a new relation type from the XML configuration to the list of user defined relation types.<p> * * @param name the name of the relation type * @param type the type of the relation type, weak or strong * * @return the new created relation type instance * * @throws CmsConfigurationException in case the resource manager configuration is already initialized */ public CmsRelationType addRelationType(String name, String type) throws CmsConfigurationException { // check if new relation types can still be added if (m_frozen) { throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0)); } CmsRelationType relationType = new CmsRelationType(m_configuredRelationTypes.size(), name, type); m_configuredRelationTypes.add(relationType); return relationType; } /** * Adds a new resource type from the XML configuration to the internal list of loaded resource types.<p> * * Resource types can also be added from a module.<p> * * @param resourceType the resource type to add * @throws CmsConfigurationException in case the resource manager configuration is already initialized */ public void addResourceType(I_CmsResourceType resourceType) throws CmsConfigurationException { // check if new resource types can still be added if (m_frozen) { throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0)); } I_CmsResourceType conflictingType = null; if (resourceType.getTypeId() == CmsResourceTypeUnknownFile.RESOURCE_TYPE_ID) { // default unknown file resource type if (m_restypeUnknownFile != null) { // error: already set conflictingType = m_restypeUnknownFile; } else { m_restypeUnknownFile = resourceType; return; } } else if (resourceType.getTypeId() == CmsResourceTypeUnknownFolder.RESOURCE_TYPE_ID) { // default unknown folder resource type if (m_restypeUnknownFolder != null) { // error: already set conflictingType = m_restypeUnknownFolder; } else { m_restypeUnknownFolder = resourceType; return; } } else { // normal resource types int conflictIndex = m_resourceTypesFromXml.indexOf(resourceType); if (conflictIndex >= 0) { conflictingType = m_resourceTypesFromXml.get(conflictIndex); } } if (conflictingType != null) { // configuration problem: the resource type (or at least the id or the name) is already configured throw new CmsConfigurationException(Messages.get().container(Messages.ERR_CONFLICTING_RESOURCE_TYPES_4, new Object[] { resourceType.getTypeName(), new Integer(resourceType.getTypeId()), conflictingType.getTypeName(), new Integer(conflictingType.getTypeId()) })); } m_resourceTypesFromXml.add(resourceType); } /** * Returns the configured content collector with the given name, or <code>null</code> if * no collector with this name is configured.<p> * * @param collectorName the name of the collector to get * @return the configured content collector with the given name */ public I_CmsResourceCollector getContentCollector(String collectorName) { return m_collectorNameMappings.get(collectorName); } /** * Returns the default resource type for the given resource name, using the * configured resource type file extensions.<p> * * In case the given name does not map to a configured resource type, * {@link CmsResourceTypePlain} is returned.<p> * * This is only required (and should <i>not</i> be used otherwise) when * creating a new resource automatically during file upload or synchronization. * Only in this case, the file type for the new resource is determined using this method. * Otherwise the resource type is <i>always</i> stored as part of the resource, * and is <i>not</i> related to the file name.<p> * * @param resourcename the resource name to look up the resource type for * * @return the default resource type for the given resource name * * @throws CmsException if something goes wrong */ public I_CmsResourceType getDefaultTypeForName(String resourcename) throws CmsException { String typeName = null; String suffix = null; if (CmsStringUtil.isNotEmpty(resourcename)) { int pos = resourcename.lastIndexOf('.'); if (pos >= 0) { suffix = resourcename.substring(pos); if (CmsStringUtil.isNotEmpty(suffix)) { suffix = suffix.toLowerCase(); typeName = m_configuration.m_extensionMappings.get(suffix); } } } if (typeName == null) { // use default type "plain" typeName = CmsResourceTypePlain.getStaticTypeName(); } if (CmsLog.INIT.isDebugEnabled()) { CmsLog.INIT.debug(Messages.get().getBundle().key(Messages.INIT_GET_RESTYPE_2, typeName, suffix)); } // look up and return the resource type return getResourceType(typeName); } /** * Returns the file extensions (suffixes) mappings to resource types.<p> * * @return a Map with all known file extensions as keys and their resource types as values. */ public Map<String, String> getExtensionMapping() { return m_configuration.m_extensionMappings; } /** * Returns the file translator.<p> * * @return the file translator */ public CmsResourceTranslator getFileTranslator() { return m_fileTranslator; } /** * Returns the folder translator.<p> * * @return the folder translator */ public CmsResourceTranslator getFolderTranslator() { return m_folderTranslator; } /** * Returns the matching HTML converter class name for the specified option name.<p> * * @param name the name of the option that should trigger the HTML converter class * * @return the matching HTML converter class name for the specified option name or <code>null</code> if no match is found */ public String getHtmlConverter(String name) { return m_htmlConverters.get(name); } /** * Returns an unmodifiable List of the configured {@link CmsHtmlConverterOption} objects.<p> * * @return an unmodifiable List of the configured {@link CmsHtmlConverterOption} objects */ public List<CmsHtmlConverterOption> getHtmlConverters() { return m_configuredHtmlConverters; } /** * Returns the loader class instance for a given resource.<p> * * @param resource the resource * @return the appropriate loader class instance * @throws CmsLoaderException if something goes wrong */ public I_CmsResourceLoader getLoader(CmsResource resource) throws CmsLoaderException { return getLoader(getResourceType(resource.getTypeId()).getLoaderId()); } /** * Returns the loader class instance for the given loader id.<p> * * @param id the id of the loader to return * @return the loader class instance for the given loader id */ public I_CmsResourceLoader getLoader(int id) { return m_loaders[id]; } /** * Returns the (unmodifiable array) list with all initialized resource loaders.<p> * * @return the (unmodifiable array) list with all initialized resource loaders */ public List<I_CmsResourceLoader> getLoaders() { return m_loaderList; } /** * Returns the MIME type for a specified file name.<p> * * If an encoding parameter that is not <code>null</code> is provided, * the returned MIME type is extended with a <code>; charset={encoding}</code> setting.<p> * * If no MIME type for the given filename can be determined, the * default <code>{@link #MIMETYPE_HTML}</code> is used.<p> * * @param filename the file name to check the MIME type for * @param encoding the default encoding (charset) in case of MIME types is of type "text" * * @return the MIME type for a specified file */ public String getMimeType(String filename, String encoding) { return getMimeType(filename, encoding, MIMETYPE_HTML); } /** * Returns the MIME type for a specified file name.<p> * * If an encoding parameter that is not <code>null</code> is provided, * the returned MIME type is extended with a <code>; charset={encoding}</code> setting.<p> * * If no MIME type for the given filename can be determined, the * provided default is used.<p> * * @param filename the file name to check the MIME type for * @param encoding the default encoding (charset) in case of MIME types is of type "text" * @param defaultMimeType the default MIME type to use if no matching type for the filename is found * * @return the MIME type for a specified file */ public String getMimeType(String filename, String encoding, String defaultMimeType) { String mimeType = null; int lastDot = filename.lastIndexOf('.'); // check the MIME type for the file extension if ((lastDot > 0) && (lastDot < (filename.length() - 1))) { mimeType = m_mimeTypes.get(filename.substring(lastDot).toLowerCase(Locale.ENGLISH)); } if (mimeType == null) { mimeType = defaultMimeType; if (mimeType == null) { // no default MIME type was provided return null; } } StringBuffer result = new StringBuffer(mimeType); if ((encoding != null) && mimeType.startsWith("text") && (mimeType.indexOf("charset") == -1)) { result.append("; charset="); result.append(encoding); } return result.toString(); } /** * Returns an unmodifiable List of the configured {@link CmsMimeType} objects.<p> * * @return an unmodifiable List of the configured {@link CmsMimeType} objects */ public List<CmsMimeType> getMimeTypes() { return m_configuredMimeTypes; } /** * Returns the name generator for XML content file names.<p> * * @return the name generator for XML content file names. */ public I_CmsFileNameGenerator getNameGenerator() { if (m_nameGenerator == null) { m_nameGenerator = new CmsDefaultFileNameGenerator(); } return m_nameGenerator; } /** * Returns an (unmodifiable) list of class names of all currently registered content collectors * ({@link I_CmsResourceCollector} objects).<p> * * @return an (unmodifiable) list of class names of all currently registered content collectors * ({@link I_CmsResourceCollector} objects) */ public List<I_CmsResourceCollector> getRegisteredContentCollectors() { return m_collectors; } /** * Returns an unmodifiable List of the configured {@link CmsRelationType} objects.<p> * * @return an unmodifiable List of the configured {@link CmsRelationType} objects */ public List<CmsRelationType> getRelationTypes() { return m_configuredRelationTypes; } /** * Convenience method to get the initialized resource type instance for the given resource, * with a fall back to special "unknown" resource types in case the resource type is not configured.<p> * * @param resource the resource to get the type for * * @return the initialized resource type instance for the given resource */ public I_CmsResourceType getResourceType(CmsResource resource) { I_CmsResourceType result = m_configuration.getResourceTypeById(resource.getTypeId()); if (result == null) { // this resource type is unknown, return the default files instead if (resource.isFolder()) { // resource is a folder if (m_restypeUnknownFolder != null) { result = m_restypeUnknownFolder; } else { result = m_configuration.getResourceTypeByName(CmsResourceTypeFolder.getStaticTypeName()); } } else { // resource is a file if (m_restypeUnknownFile != null) { result = m_restypeUnknownFile; } else { result = m_configuration.getResourceTypeByName(CmsResourceTypeBinary.getStaticTypeName()); } } } return result; } /** * Returns the initialized resource type instance for the given id.<p> * * @param typeId the id of the resource type to get * * @return the initialized resource type instance for the given id * * @throws CmsLoaderException if no resource type is available for the given id */ public I_CmsResourceType getResourceType(int typeId) throws CmsLoaderException { I_CmsResourceType result = m_configuration.getResourceTypeById(typeId); if (result == null) { throw new CmsLoaderException( Messages.get().container(Messages.ERR_UNKNOWN_RESTYPE_ID_REQ_1, new Integer(typeId))); } return result; } /** * Returns the initialized resource type instance for the given resource type name.<p> * * @param typeName the name of the resource type to get * * @return the initialized resource type instance for the given name * * @throws CmsLoaderException if no resource type is available for the given name */ public I_CmsResourceType getResourceType(String typeName) throws CmsLoaderException { I_CmsResourceType result = m_configuration.getResourceTypeByName(typeName); if (result != null) { return result; } throw new CmsLoaderException(Messages.get().container(Messages.ERR_UNKNOWN_RESTYPE_NAME_REQ_1, typeName)); } /** * Returns the (unmodifiable) list with all initialized resource types.<p> * * @return the (unmodifiable) list with all initialized resource types */ public List<I_CmsResourceType> getResourceTypes() { return m_configuration.m_resourceTypeList; } /** * Returns the (unmodifiable) list with all initialized resource types including unknown types.<p> * * @return the (unmodifiable) list with all initialized resource types including unknown types */ public List<I_CmsResourceType> getResourceTypesWithUnknown() { return m_configuration.m_resourceTypeListWithUnknown; } /** * The configured default type for files when the resource type is missing.<p> * * @return the configured default type for files */ public I_CmsResourceType getResTypeUnknownFile() { return m_restypeUnknownFile; } /** * The configured default type for folders when the resource type is missing.<p> * * @return The configured default type for folders */ public I_CmsResourceType getResTypeUnknownFolder() { return m_restypeUnknownFolder; } /** * Returns a template loader facade for the given file.<p> * @param cms the current OpenCms user context * @param resource the requested file * @param templateProperty the property to read for the template * * @return a resource loader facade for the given file * @throws CmsException if something goes wrong */ public CmsTemplateLoaderFacade getTemplateLoaderFacade(CmsObject cms, CmsResource resource, String templateProperty) throws CmsException { String templateProp = cms.readPropertyObject(resource, templateProperty, true).getValue(); if (templateProp == null) { // use default template, if template is not set templateProp = DEFAULT_TEMPLATE; if (!cms.existsResource(templateProp, CmsResourceFilter.IGNORE_EXPIRATION)) { // no template property defined, this is a must for facade loaders throw new CmsLoaderException(Messages.get().container(Messages.ERR_NONDEF_PROP_2, templateProperty, cms.getSitePath(resource))); } } else if (!cms.existsResource(templateProp, CmsResourceFilter.IGNORE_EXPIRATION)) { // use default template, if template does not exist if (cms.existsResource(DEFAULT_TEMPLATE, CmsResourceFilter.IGNORE_EXPIRATION)) { templateProp = DEFAULT_TEMPLATE; } } CmsResource template = cms.readFile(templateProp, CmsResourceFilter.IGNORE_EXPIRATION); return new CmsTemplateLoaderFacade(getLoader(template), resource, template); } /** * Returns the XSD translator.<p> * * @return the XSD translator */ public CmsResourceTranslator getXsdTranslator() { return m_xsdTranslator; } /** * Checks if an initialized resource type instance equal to the given resource type is available.<p> * * @param type the resource type to check * @return <code>true</code> if such a resource type has been configured, <code>false</code> otherwise * * @see #getResourceType(String) * @see #getResourceType(int) */ public boolean hasResourceType(I_CmsResourceType type) { return hasResourceType(type.getTypeId()); } /** * Checks if an initialized resource type instance for the given resource type is is available.<p> * * @param typeId the id of the resource type to check * @return <code>true</code> if such a resource type has been configured, <code>false</code> otherwise * * @see #getResourceType(int) */ public boolean hasResourceType(int typeId) { return m_configuration.getResourceTypeById(typeId) != null; } /** * Checks if an initialized resource type instance for the given resource type name is available.<p> * * @param typeName the name of the resource type to check * @return <code>true</code> if such a resource type has been configured, <code>false</code> otherwise * * @see #getResourceType(String) */ public boolean hasResourceType(String typeName) { return m_configuration.getResourceTypeByName(typeName) != null; } /** * @see org.opencms.configuration.I_CmsConfigurationParameterHandler#initConfiguration() * * @throws CmsConfigurationException in case of duplicate resource types in the configuration */ public void initConfiguration() throws CmsConfigurationException { if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_LOADER_CONFIG_FINISHED_0)); } m_resourceTypesFromXml = Collections.unmodifiableList(m_resourceTypesFromXml); m_loaderList = Collections.unmodifiableList(m_loaderList); Collections.sort(m_configuredMimeTypes); m_configuredMimeTypes = Collections.unmodifiableList(m_configuredMimeTypes); m_configuredRelationTypes = Collections.unmodifiableList(m_configuredRelationTypes); // initialize the HTML converters initHtmlConverters(); m_configuredHtmlConverters = Collections.unmodifiableList(m_configuredHtmlConverters); // initialize the resource types initResourceTypes(); // initialize the MIME types initMimeTypes(); } /** * Initializes all additional resource types stored in the modules.<p> * * @param cms an initialized OpenCms user context with "module manager" role permissions * * @throws CmsRoleViolationException in case the provided OpenCms user context did not have "module manager" role permissions * @throws CmsConfigurationException in case of duplicate resource types in the configuration */ public synchronized void initialize(CmsObject cms) throws CmsRoleViolationException, CmsConfigurationException { if (OpenCms.getRunLevel() > OpenCms.RUNLEVEL_1_CORE_OBJECT) { // some simple test cases don't require this check OpenCms.getRoleManager().checkRole(cms, CmsRole.DATABASE_MANAGER); } // initialize the resource types initResourceTypes(); // call initialize method on all resource types Iterator<I_CmsResourceType> i = m_configuration.m_resourceTypeList.iterator(); while (i.hasNext()) { I_CmsResourceType type = i.next(); type.initialize(cms); } if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_LOADER_CONFIG_FINISHED_0)); } } /** * Loads the requested resource and writes the contents to the response stream.<p> * * @param req the current HTTP request * @param res the current HTTP response * @param cms the current OpenCms user context * @param resource the requested resource * @throws ServletException if something goes wrong * @throws IOException if something goes wrong * @throws CmsException if something goes wrong */ public void loadResource(CmsObject cms, CmsResource resource, HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException, CmsException { res.setContentType(getMimeType(resource.getName(), cms.getRequestContext().getEncoding())); I_CmsResourceLoader loader = getLoader(resource); loader.load(cms, resource, req, res); } /** * Configures the URL name generator for XML contents.<p> * * @param nameGenerator the configured name generator class * * @throws CmsConfigurationException if something goes wrong */ public void setNameGenerator(I_CmsFileNameGenerator nameGenerator) throws CmsConfigurationException { if (m_frozen) { throw new CmsConfigurationException(Messages.get().container(Messages.ERR_NO_CONFIG_AFTER_STARTUP_0)); } m_nameGenerator = nameGenerator; } /** * Sets the folder, the file and the XSD translator.<p> * * @param folderTranslator the folder translator to set * @param fileTranslator the file translator to set * @param xsdTranslator the XSD translator to set */ public void setTranslators(CmsResourceTranslator folderTranslator, CmsResourceTranslator fileTranslator, CmsResourceTranslator xsdTranslator) { m_folderTranslator = folderTranslator; m_fileTranslator = fileTranslator; m_xsdTranslator = xsdTranslator; } /** * Shuts down this resource manage instance.<p> * * @throws Exception in case of errors during shutdown */ public synchronized void shutDown() throws Exception { Iterator<I_CmsResourceLoader> it = m_loaderList.iterator(); while (it.hasNext()) { // destroy all resource loaders I_CmsResourceLoader loader = it.next(); loader.destroy(); } m_loaderList = null; m_loaders = null; m_collectorNameMappings = null; m_mimeTypes = null; m_configuredMimeTypes = null; m_configuredRelationTypes = null; m_configuredHtmlConverters = null; m_htmlConverters = null; if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_SHUTDOWN_1, this.getClass().getName())); } } /** * Initialize the HTML converters.<p> * * HTML converters are configured in the OpenCms <code>opencms-vfs.xml</code> configuration file.<p> * * For legacy reasons, the default JTidy HTML converter has to be loaded if no explicit HTML converters * are configured in the configuration file.<p> */ private void initHtmlConverters() { // check if any HTML converter configuration were found if (m_configuredHtmlConverters.size() == 0) { // no converters configured, add default JTidy converter configuration String classJTidy = CmsHtmlConverterJTidy.class.getName(); m_configuredHtmlConverters .add(new CmsHtmlConverterOption(CmsHtmlConverter.PARAM_ENABLED, classJTidy, true)); m_configuredHtmlConverters .add(new CmsHtmlConverterOption(CmsHtmlConverter.PARAM_XHTML, classJTidy, true)); m_configuredHtmlConverters .add(new CmsHtmlConverterOption(CmsHtmlConverter.PARAM_WORD, classJTidy, true)); m_configuredHtmlConverters .add(new CmsHtmlConverterOption(CmsHtmlConverter.PARAM_REPLACE_PARAGRAPHS, classJTidy, true)); } // initialize lookup map of configured HTML converters m_htmlConverters = new HashMap<String, String>(m_configuredHtmlConverters.size()); for (Iterator<CmsHtmlConverterOption> i = m_configuredHtmlConverters.iterator(); i.hasNext();) { CmsHtmlConverterOption converterOption = i.next(); m_htmlConverters.put(converterOption.getName(), converterOption.getClassName()); } } /** * Initialize the MIME types.<p> * * MIME types are configured in the OpenCms <code>opencms-vfs.xml</code> configuration file.<p> * * For legacy reasons, the MIME types are also read from a file <code>"mimetypes.properties"</code> * that must be located in the default <code>"classes"</code> folder of the web application.<p> */ private void initMimeTypes() { // legacy MIME type initialization: try to read properties file Properties mimeTypes = new Properties(); try { // first try: read MIME types from default package mimeTypes.load(getClass().getClassLoader().getResourceAsStream("mimetypes.properties")); } catch (Throwable t) { try { // second try: read MIME types from loader package (legacy reasons, there are no types by default) mimeTypes.load( getClass().getClassLoader().getResourceAsStream("org/opencms/loader/mimetypes.properties")); } catch (Throwable t2) { if (LOG.isInfoEnabled()) { LOG.info(Messages.get().getBundle().key(Messages.LOG_READ_MIMETYPES_FAILED_2, "mimetypes.properties", "org/opencms/loader/mimetypes.properties")); } } } // initialize the Map with all available MIME types List<CmsMimeType> combinedMimeTypes = new ArrayList<CmsMimeType>( mimeTypes.size() + m_configuredMimeTypes.size()); // first add all MIME types from the configuration combinedMimeTypes.addAll(m_configuredMimeTypes); // now add the MIME types from the properties Iterator<Map.Entry<Object, Object>> i = mimeTypes.entrySet().iterator(); while (i.hasNext()) { Map.Entry<Object, Object> entry = i.next(); CmsMimeType mimeType = new CmsMimeType(entry.getKey().toString(), entry.getValue().toString(), false); if (!combinedMimeTypes.contains(mimeType)) { // make sure no MIME types from the XML configuration are overwritten combinedMimeTypes.add(mimeType); } } // create a lookup Map for the MIME types m_mimeTypes = new HashMap<String, String>(mimeTypes.size()); Iterator<CmsMimeType> j = combinedMimeTypes.iterator(); while (j.hasNext()) { CmsMimeType mimeType = j.next(); m_mimeTypes.put(mimeType.getExtension(), mimeType.getType()); } if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info( Messages.get().getBundle().key(Messages.INIT_NUM_MIMETYPES_1, new Integer(m_mimeTypes.size()))); } } /** * Adds a new resource type to the internal list of loaded resource types and initializes * options for the resource type.<p> * * @param resourceType the resource type to add * @param configuration the resource configuration */ private synchronized void initResourceType(I_CmsResourceType resourceType, CmsResourceManagerConfiguration configuration) { // add the loader to the internal list of loaders configuration.addResourceType(resourceType); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ADD_RESTYPE_3, resourceType.getTypeName(), new Integer(resourceType.getTypeId()), resourceType.getClass().getName())); } // add the mappings List<String> mappings = resourceType.getConfiguredMappings(); Iterator<String> i = mappings.iterator(); while (i.hasNext()) { String mapping = i.next(); // only add this mapping if a mapping with this file extension does not // exist already if (!configuration.m_extensionMappings.containsKey(mapping)) { configuration.m_extensionMappings.put(mapping, resourceType.getTypeName()); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_MAP_RESTYPE_2, mapping, resourceType.getTypeName())); } } } } /** * Initializes member variables required for storing the resource types.<p> * * @throws CmsConfigurationException in case of duplicate resource types in the configuration */ private synchronized void initResourceTypes() throws CmsConfigurationException { if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_STARTING_LOADER_CONFIG_0)); } CmsResourceManagerConfiguration newConfiguration = new CmsResourceManagerConfiguration(); if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ADD_RESTYPE_FROM_FILE_2, new Integer(m_resourceTypesFromXml.size()), CmsVfsConfiguration.DEFAULT_XML_FILE_NAME)); } // build a new resource type list from the resource types of the XML configuration Iterator<I_CmsResourceType> i; i = m_resourceTypesFromXml.iterator(); while (i.hasNext()) { I_CmsResourceType resourceType = i.next(); initResourceType(resourceType, newConfiguration); } // add all resource types declared in the modules CmsModuleManager moduleManager = OpenCms.getModuleManager(); if (moduleManager != null) { Iterator<String> modules = moduleManager.getModuleNames().iterator(); while (modules.hasNext()) { CmsModule module = moduleManager.getModule(modules.next()); if ((module != null) && (module.getResourceTypes().size() > 0)) { // module contains resource types if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ADD_NUM_RESTYPES_FROM_MOD_2, new Integer(module.getResourceTypes().size()), module.getName())); } Iterator<I_CmsResourceType> j = module.getResourceTypes().iterator(); while (j.hasNext()) { I_CmsResourceType resourceType = j.next(); I_CmsResourceType conflictingType = null; if (resourceType.getTypeId() == CmsResourceTypeUnknownFile.RESOURCE_TYPE_ID) { // default unknown file resource type if (m_restypeUnknownFile != null) { // error: already set conflictingType = m_restypeUnknownFile; } else { m_restypeUnknownFile = resourceType; continue; } } else if (resourceType.getTypeId() == CmsResourceTypeUnknownFolder.RESOURCE_TYPE_ID) { // default unknown folder resource type if (m_restypeUnknownFolder != null) { // error: already set conflictingType = m_restypeUnknownFolder; } else { m_restypeUnknownFile = resourceType; continue; } } else { // normal resource types conflictingType = newConfiguration.getResourceTypeById(resourceType.getTypeId()); } if (conflictingType != null) { throw new CmsConfigurationException( Messages.get().container(Messages.ERR_CONFLICTING_MODULE_RESOURCE_TYPES_5, new Object[] { resourceType.getTypeName(), new Integer(resourceType.getTypeId()), module.getName(), conflictingType.getTypeName(), new Integer(conflictingType.getTypeId()) })); } initResourceType(resourceType, newConfiguration); } } } } // freeze the current configuration newConfiguration.freeze(m_restypeUnknownFile, m_restypeUnknownFile); m_configuration = newConfiguration; m_frozen = true; if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_RESOURCE_TYPE_INITIALIZED_0)); } } }