/*******************************************************************************
* Copyright (c) 2005 Oracle Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Gerry Kessler - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.core.internal.project.facet;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.emf.common.util.EList;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.j2ee.webapplication.WebapplicationFactory;
import org.eclipse.jst.javaee.core.JavaeeFactory;
import org.eclipse.jst.javaee.web.WebAppVersionType;
import org.eclipse.jst.javaee.web.WebFactory;
import org.eclipse.jst.jsf.core.JSFVersion;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.Messages;
import org.eclipse.jst.jsf.core.internal.jsflibraryregistry.ArchiveFile;
import org.eclipse.jst.jsf.core.internal.jsflibraryregistry.JSFLibrary;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
/**
*
*/
@SuppressWarnings("deprecation")
public abstract class JSFUtils {
/**
* The default name for the Faces servlet
*/
public static final String JSF_DEFAULT_SERVLET_NAME = "Faces Servlet"; //$NON-NLS-1$
/**
* The default name of the Faces servlet class
*/
public static final String JSF_SERVLET_CLASS = "javax.faces.webapp.FacesServlet"; //$NON-NLS-1$
/**
* The name of the context parameter used for JSF configuration files
*/
public static final String JSF_CONFIG_CONTEXT_PARAM = "javax.faces.CONFIG_FILES"; //$NON-NLS-1$
/**
* The name of the context parameter used for defining the default JSP file extension
*/
public static final String JSF_DEFAULT_SUFFIX_CONTEXT_PARAM = "javax.faces.DEFAULT_SUFFIX"; //$NON-NLS-1$
/**
* The path to the default application configuration file
*/
public static final String JSF_DEFAULT_CONFIG_PATH = "/WEB-INF/faces-config.xml"; //$NON-NLS-1$
/**
* Default URL mapping to faces servlet
*/
public static final String JSF_DEFAULT_URL_MAPPING = "/faces/*"; //$NON-NLS-1$
/**
* the key for implementation libraries in persistent properties
*/
public static final String PP_JSF_IMPLEMENTATION_LIBRARIES = "jsf.implementation.libraries"; //$NON-NLS-1$
/**
* the key for component libraries in persistent properties
*/
public static final String PP_JSF_COMPONENT_LIBRARIES = "jsf.component.libraries"; //$NON-NLS-1$
/**
* the key for implementation type in persistent properties
*/
public static final String PP_JSF_IMPLEMENTATION_TYPE = "jsf.implementation.type"; //$NON-NLS-1$
private static final String DEFAULT_DEFAULT_MAPPING_SUFFIX = "jsp"; //$NON-NLS-1$
/**
* In cases where there is no servlet mapping defined (where it can be implicit and provided
* by the container), this system property can be used to provide the "implicit" servlet
* mapping.
*/
private static final String SYS_PROP_SERVLET_MAPPING = "org.eclipse.jst.jsf.servletMapping"; //$NON-NLS-1$
private final JSFVersion _version;
private final IModelProvider _modelProvider;
/**
* @param version
* @param modelProvider
*/
protected JSFUtils(final JSFVersion version, final IModelProvider modelProvider)
{
_version = version;
_modelProvider = modelProvider;
}
/**
* @return the jsf version that this instance is for.
*/
public final JSFVersion getVersion()
{
return _version;
}
/**
* @param config
* @return servlet display name to use from wizard data model
*/
protected final String getDisplayName(IDataModel config) {
String displayName = config.getStringProperty(IJSFFacetInstallDataModelProperties.SERVLET_NAME);
if (displayName == null || displayName.trim().length() == 0)
displayName = JSF_DEFAULT_SERVLET_NAME;
return displayName.trim();
}
/**
* @param config
* @return servlet display name to use from wizard data model
*/
protected final String getServletClassname(IDataModel config) {
String className = config.getStringProperty(IJSFFacetInstallDataModelProperties.SERVLET_CLASSNAME);
if (className == null || className.trim().equals("")) //$NON-NLS-1$
className = JSF_SERVLET_CLASS;
return className.trim();
}
/**
* @return IModelProvider
*/
public final IModelProvider getModelProvider() {
Object webAppObj = _modelProvider.getModelObject();
if (webAppObj == null)
{
return null;
}
return _modelProvider;
}
/**
* @param configPath
*/
public final void createConfigFile(IPath configPath)
{
FileOutputStream os = null;
// final String QUOTE = new String(new char[] { '"' });
try {
IPath dirPath = configPath.removeLastSegments(1);
dirPath.toFile().mkdirs();
File file = configPath.toFile();
file.createNewFile();
os = new FileOutputStream(file);
printConfigFile(os);
} catch (FileNotFoundException e) {
JSFCorePlugin.log(IStatus.ERROR, Messages.JSFUtils_ErrorCreatingConfigFile, e);
} catch (IOException e) {
JSFCorePlugin.log(IStatus.ERROR, Messages.JSFUtils_ErrorCreatingConfigFile, e);
} finally {
if (os != null) {
try {
os.close();
} catch (IOException e) {
JSFCorePlugin.log(IStatus.ERROR, Messages.JSFUtils_ErrorClosingConfigFile, e);
}
}
}
}
/**
* @param out
*/
protected final void printConfigFile(final OutputStream out)
{
PrintWriter pw = null;
try
{
pw = new PrintWriter(out);
doVersionSpecificConfigFile(pw);
}
finally
{
if (pw != null)
{
pw.close();
}
}
}
/**
* @param pw
*/
public abstract void doVersionSpecificConfigFile(final PrintWriter pw);
/**
* @param webAppObj
* @return true if this going into a JavaEE (1.5 and later) or a J2EE (1.4 and earlier)
* configured application.
*/
public boolean isJavaEE(final Object webAppObj)
{
if (webAppObj instanceof org.eclipse.jst.javaee.web.WebApp)
{
org.eclipse.jst.javaee.web.WebApp webApp = (org.eclipse.jst.javaee.web.WebApp)webAppObj;
return WebAppVersionType.VALUES.contains(webApp.getVersion());
}
return false;
}
/**
* @param config
* @return list of URL patterns from the datamodel
*/
protected final List<String> getServletMappings(final IDataModel config) {
final List<String> mappings = new ArrayList<String>();
final String[] patterns = (String[])config.getProperty(IJSFFacetInstallDataModelProperties.SERVLET_URL_PATTERNS);
if (patterns != null)
{
for (final String pattern : patterns)
{
mappings.add(pattern);
}
}
return mappings;
}
/**
* Does an update of the web application's config file.
*
* @param webApp must be WebApp of the appropriate type.
* @param config
* @throws ClassCastException if webApp is not the appropriate type.
*/
public abstract void updateWebApp(Object webApp, IDataModel config);
/**
* Called on a facet uninstall to remove JSF related changes.
* @param webApp
*/
public abstract void rollbackWebApp(Object webApp);
/**
* @param fileExtension
* @return true if the file extension is deemed to be for a JSF.
*/
protected boolean isValidKnownExtension(String fileExtension) {
//Bug 313830 - JSFUtils should use content type instead file extension in isValidKnownExtension.
List<String> validKnownExtensions = new ArrayList<String>();
for (String contentTypeId: new String[]{
"org.eclipse.jst.jsp.core.jspsource", //$NON-NLS-1$
"org.eclipse.jst.jsp.core.jspfragmentsource", //$NON-NLS-1$
"jsf.facelet"}) { //$NON-NLS-1$
IContentType contentType = Platform.getContentTypeManager().getContentType(contentTypeId);
if (contentType != null) {
String[] contentTypeExts = contentType.getFileSpecs(IContentType.FILE_EXTENSION_SPEC);
if (contentTypeExts != null) {
validKnownExtensions.addAll(Arrays.asList(contentTypeExts));
}
}
}
if (fileExtension != null) {
return validKnownExtensions.contains(fileExtension);
}
return false;
}
/**
* @param resource
* @return true if the resource is deemed to be a JSF page.
*/
protected boolean isJSFPage(IResource resource) {
// currently always return true if resource != null.
// need to find quick way of determining whether this is a JSF JSP Page
boolean isJSFPage = true;
if (resource == null) {
isJSFPage = false;
}
return isJSFPage;
}
/**
* @param webApp
* @return the default file extension from the context param. Default is
* "jsp" if no context param.
*/
protected String getDefaultSuffix(Object webApp) {
String contextParam = null;
if (webApp != null) {
if(isJavaEE(webApp)) {
contextParam = JEEUtils.getContextParam((org.eclipse.jst.javaee.web.WebApp) webApp, JSF_DEFAULT_SUFFIX_CONTEXT_PARAM);
}
else {
contextParam = J2EEUtils.getContextParam((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, JSF_DEFAULT_SUFFIX_CONTEXT_PARAM);
}
}
if (contextParam == null) {
return getDefaultDefaultSuffix();
}
return normalizeSuffix(contextParam);
}
/**
* @return the default value for the default mapping suffix
*/
protected String getDefaultDefaultSuffix()
{
return DEFAULT_DEFAULT_MAPPING_SUFFIX;
}
/**
* @param name
* @param value
* @return the
*/
protected final String calculateSuffix(final String name, final String value)
{
if (name != null
&& JSF_DEFAULT_SUFFIX_CONTEXT_PARAM.equals(name
.trim()))
{
return normalizeSuffix(value != null ? value.trim() : null);
}
return null;
}
/**
* @param defSuffix
* @return the suffix value with any leading dot removed
*/
protected final String normalizeSuffix(String defSuffix)
{
if (defSuffix != null && defSuffix.startsWith(".")) //$NON-NLS-1$
{
defSuffix = defSuffix.substring(1);
}
return defSuffix;
}
/**
* Holds all the obsolete JSF Library stuff. This will go away post-Helios.
* @author cbateman
*
*/
public static class JSFLibraryHandler
{
/**
* Construct an array that hold paths for all JARs in a JSF library.
*
* @param jsfLib
* @param logMissingJar true to log an error for each invalid JAR.
* @return elements
*/
public final IPath[] getJARPathforJSFLib(JSFLibrary jsfLib, boolean logMissingJar) {
EList archiveFiles = jsfLib.getArchiveFiles();
int numJars = archiveFiles.size();
IPath[] elements = new IPath[numJars];
ArchiveFile ar = null;
for (int i= 0; i < numJars; i++) {
ar = (ArchiveFile)archiveFiles.get(i);
if ( !ar.exists() && logMissingJar ) {
logErroronMissingJAR(jsfLib, ar);
}
elements[i] = new Path(((ArchiveFile)archiveFiles.get(i)).getResolvedSourceLocation()).makeAbsolute();
}
return elements;
}
private int numberofValidJar(EList archiveFiles) {
int total = 0;
final Iterator it = archiveFiles.iterator();
ArchiveFile ar = null;
while(it.hasNext()) {
ar = (ArchiveFile) it.next();
if (ar.exists()) {
total++;
}
}
return total;
}
private void logErroronMissingJAR(JSFLibrary jsfLib, ArchiveFile ar) {
String msg = NLS.bind(Messages.JSFUtils_MissingJAR,
ar.getName(),
jsfLib.getLabel());
JSFCorePlugin.log(IStatus.ERROR, msg);
}
/**
* Construct an array that hold paths for all JARs in a JSF library.
* However, archive files that no longer exist are filtered out.
*
* @param jsfLib
* @param logMissingJar true to log an error for each invalid JAR.
* @return elements
*/
public final IPath[] getJARPathforJSFLibwFilterMissingJars(JSFLibrary jsfLib, boolean logMissingJar) {
EList archiveFiles = jsfLib.getArchiveFiles();
int numJars = numberofValidJar(archiveFiles);
IPath[] elements = new IPath[numJars];
ArchiveFile ar = null;
int idxValidJar = 0;
for (int i= 0; i < archiveFiles.size(); i++) {
ar = (ArchiveFile)archiveFiles.get(i);
if ( !ar.exists() ) {
if (logMissingJar) {
logErroronMissingJAR(jsfLib, ar);
}
} else {
elements[idxValidJar] = new Path(((ArchiveFile)archiveFiles.get(i)).getResolvedSourceLocation()).makeAbsolute();
idxValidJar++;
}
}
return elements;
}
}
/**
* Finds and returns a JSF Servlet definition, or null if servlet is not defined.
*
* @param webApp
* @return Servlet or null
*/
protected Object findJSFServlet(Object webApp) {
if(isJavaEE(webApp)) {
return JEEUtils.findServlet((org.eclipse.jst.javaee.web.WebApp) webApp, JSF_SERVLET_CLASS);
}
return J2EEUtils.findServlet((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, JSF_SERVLET_CLASS);
}
/**
* Creates servlet reference in WebApp if not present or updates servlet
* name if found using the passed configuration.
*
* @param webApp
* @param config
* @param servlet
* @return Servlet servlet - if passed servlet was null, will return created
* servlet
*/
protected Object createOrUpdateServletRef(final Object webApp,
final IDataModel config, Object servlet)
{
String displayName = getDisplayName(config);
String className = getServletClassname(config);
if(isJavaEE(webApp)) {
return JEEUtils.createOrUpdateServletRef((org.eclipse.jst.javaee.web.WebApp) webApp, displayName, className, (org.eclipse.jst.javaee.web.Servlet) servlet);
}
return J2EEUtils.createOrUpdateServletRef((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, displayName, className, (org.eclipse.jst.j2ee.webapplication.Servlet) servlet);
}
/**
* Creates servlet-mappings for the servlet for 2.5 WebModules or greated
*
* @param webApp
* @param urlMappingList
* - list of string values to be used in url-pattern for
* servlet-mapping
* @param servlet
*/
protected void setUpURLMappings(final Object webApp,
final List<String> urlMappingList, final Object servlet)
{
if(isJavaEE(webApp)) {
JEEUtils.setUpURLMappings((org.eclipse.jst.javaee.web.WebApp) webApp, urlMappingList, (org.eclipse.jst.javaee.web.Servlet) servlet);
}
else {
J2EEUtils.setUpURLMappings((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, urlMappingList, (org.eclipse.jst.j2ee.webapplication.Servlet) servlet);
}
}
/**
* Removes servlet-mappings for servlet using servlet-name for >= 2.5 WebModules.
* @param webApp
* @param servlet
*/
protected void removeURLMappings(final Object webApp, final Object servlet) {
if(isJavaEE(webApp)) {
JEEUtils.removeURLMappings((org.eclipse.jst.javaee.web.WebApp) webApp, (org.eclipse.jst.javaee.web.Servlet) servlet);
}
else {
J2EEUtils.removeURLMappings((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, (org.eclipse.jst.j2ee.webapplication.Servlet) servlet);
}
}
/**
* Removes servlet definition
* @param webApp
* @param servlet
*/
protected void removeJSFServlet(final Object webApp, final Object servlet) {
if(isJavaEE(webApp)) {
JEEUtils.removeServlet((org.eclipse.jst.javaee.web.WebApp) webApp, (org.eclipse.jst.javaee.web.Servlet) servlet);
}
else {
J2EEUtils.removeServlet((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, (org.eclipse.jst.j2ee.webapplication.Servlet) servlet);
}
}
/**
* Removes context-param
* @param webApp
*/
protected void removeJSFContextParams(final Object webApp) {
if(isJavaEE(webApp)) {
JEEUtils.removeContextParam((org.eclipse.jst.javaee.web.WebApp) webApp, JSF_CONFIG_CONTEXT_PARAM);
}
else {
J2EEUtils.removeContextParam((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, JSF_CONFIG_CONTEXT_PARAM);
}
}
/**
* Creates or updates context-params
* @param webApp
* @param config
*/
protected void setupContextParams(final Object webApp, final IDataModel config) {
final String paramValue = config.getStringProperty(IJSFFacetInstallDataModelProperties.CONFIG_PATH);
if (paramValue != null && !paramValue.equals(JSF_DEFAULT_CONFIG_PATH)) {
if(isJavaEE(webApp)) {
JEEUtils.setupContextParam((org.eclipse.jst.javaee.web.WebApp) webApp, JSF_CONFIG_CONTEXT_PARAM, paramValue);
}
else {
J2EEUtils.setupContextParam((org.eclipse.jst.j2ee.webapplication.WebApp) webApp, JSF_CONFIG_CONTEXT_PARAM, paramValue);
}
}
}
/**
* @param map
* @param webApp
* @return extension from map. Will return null if file extension not found
* in url patterns.
*/
protected String getFileExtensionFromMap(final Object webApp, final Object map) {
if(isJavaEE(webApp)) {
return JEEUtils.getFileExtensionFromMap((org.eclipse.jst.javaee.web.ServletMapping) map);
}
return J2EEUtils.getFileExtensionFromMap((org.eclipse.jst.j2ee.webapplication.ServletMapping) map);
}
/**
* @param webApp
* @param map
* @return prefix mapping. may return null.
*/
protected String getPrefixMapping(final Object webApp, final Object map) {
if(isJavaEE(webApp)) {
return JEEUtils.getPrefixMapping((org.eclipse.jst.javaee.web.ServletMapping) map);
}
return J2EEUtils.getPrefixMapping((org.eclipse.jst.j2ee.webapplication.ServletMapping) map);
}
/**
* @param webAppObj
* @param resource
* @param existingURL
* @return the modified url path for the (possibly) jsf resource.
*/
public IPath getFileUrlPath(Object webAppObj, IResource resource,
IPath existingURL) {
// if not a JSF page, do nothing
if (!isJSFPage(resource))
{
return null;
}
Object servlet = findJSFServlet(webAppObj);
List implicitServletMappings = new ArrayList();
if (servlet == null)
{
servlet = createImplicitServletAndMapping(webAppObj, implicitServletMappings);
}
String defaultSuffix = getDefaultSuffix(webAppObj);
// is the resource using default_suffix
String fileExtension = resource.getFileExtension();
boolean canUseExtensionMapping = fileExtension != null && fileExtension.equalsIgnoreCase(defaultSuffix);
// if not using default extension and is not a known file extension,
// then we will abort
if (!canUseExtensionMapping
&& !isValidKnownExtension(resource.getFileExtension()))
return null;
if(isJavaEE(webAppObj)) {
org.eclipse.jst.javaee.web.WebApp webApp = (org.eclipse.jst.javaee.web.WebApp) webAppObj;
final String servletName = ((org.eclipse.jst.javaee.web.Servlet) servlet).getServletName();
String foundFileExtension = null;
List mappings;
if (webApp.getServletMappings().size() > 0) {
mappings = webApp.getServletMappings();
} else {
mappings = implicitServletMappings;
}
for (final org.eclipse.jst.javaee.web.ServletMapping map : (List<org.eclipse.jst.javaee.web.ServletMapping>) mappings)
{
if (map != null &&
map.getServletName() != null &&
map.getServletName().trim().equals(servletName.trim()))
{
foundFileExtension = getFileExtensionFromMap(webAppObj, map);
if (foundFileExtension != null && canUseExtensionMapping)
{
return existingURL.removeFileExtension()
.addFileExtension(foundFileExtension);
}
String foundPrefixMapping = getPrefixMapping(webAppObj, map);
if (foundPrefixMapping != null)
{
return new Path(foundPrefixMapping).append(existingURL);
}
}
}
if (!canUseExtensionMapping && foundFileExtension != null)
{
// we could prompt user that this may not work...
// for now we will return the extension mapping
return existingURL.removeFileExtension().addFileExtension(
foundFileExtension);
}
// we could, at this point, add a url mapping to the faces servlet,
// or prompt user that it may be a good idea to add one...
}
else {
List mappings;
if (((org.eclipse.jst.j2ee.webapplication.Servlet)servlet).getMappings().size() > 0) {
mappings = ((org.eclipse.jst.j2ee.webapplication.Servlet)servlet).getMappings();
} else {
mappings = implicitServletMappings;
}
Iterator itMappings = mappings.iterator();
org.eclipse.jst.j2ee.webapplication.ServletMapping map = null;
String foundFileExtension = null;
String foundPrefixMapping = null;
while (itMappings.hasNext())
{
map = (org.eclipse.jst.j2ee.webapplication.ServletMapping)itMappings.next();
foundFileExtension = getFileExtensionFromMap(webAppObj, map);
if (foundFileExtension != null && canUseExtensionMapping)
{
return existingURL.removeFileExtension().addFileExtension(foundFileExtension);
}
if (foundPrefixMapping == null)
{
foundPrefixMapping = getPrefixMapping(webAppObj, map);
}
}
if (foundPrefixMapping != null)
{
return new Path(foundPrefixMapping).append(existingURL);
}
if (! canUseExtensionMapping && foundFileExtension != null){
//we could prompt user that this may not work...
//for now we will return the extension mapping
return existingURL.removeFileExtension().addFileExtension(foundFileExtension);
}
// we could, at this point, add a url mapping to the faces servlet,
// or prompt user that it may be a good idea to add one...
}
return null;
}
/**
* This creates a servlet and servlet mapping suitable for
* {@link #getFileUrlPath(Object, IResource, IPath)} to be able to proceed, but the returned
* objects are not fully-initialized for any and all purposes. USE WITH CAUTION.
*
* @param webApp Web App object.
* @param mappings List to which the that the created servlet mapping will be added.
* @return Servlet instance (and a servlet mapping added to mappings).
*/
private Object createImplicitServletAndMapping(Object webApp, List mappings) {
Object servlet;
String sysPropServletMapping = System.getProperty(SYS_PROP_SERVLET_MAPPING);
if (sysPropServletMapping == null) {
sysPropServletMapping = JSF_DEFAULT_URL_MAPPING;
}
if (isJavaEE(webApp)) {
servlet = WebFactory.eINSTANCE.createServlet();
((org.eclipse.jst.javaee.web.Servlet)servlet).setServletName(JSF_DEFAULT_SERVLET_NAME);
org.eclipse.jst.javaee.web.ServletMapping mapping = WebFactory.eINSTANCE.createServletMapping();
mapping.setServletName(JSF_DEFAULT_SERVLET_NAME);
org.eclipse.jst.javaee.core.UrlPatternType pattern = JavaeeFactory.eINSTANCE.createUrlPatternType();
pattern.setValue(sysPropServletMapping);
mapping.getUrlPatterns().add(pattern);
mappings.add(mapping);
} else {
servlet = WebapplicationFactory.eINSTANCE.createServlet();
((org.eclipse.jst.j2ee.webapplication.Servlet)servlet).setServletName(JSF_DEFAULT_SERVLET_NAME);
org.eclipse.jst.j2ee.webapplication.ServletMapping mapping = WebapplicationFactory.eINSTANCE.createServletMapping();
mapping.setUrlPattern(sysPropServletMapping);
mappings.add(mapping);
}
return servlet;
}
}