/*******************************************************************************
* 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:
* Ian Trimble - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.core.jsfappconfig;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.util.EList;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.j2ee.common.ParamValue;
import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.j2ee.model.ModelProviderManager;
import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
import org.eclipse.jst.j2ee.webapplication.ContextParam;
import org.eclipse.jst.j2ee.webapplication.WebApp;
import org.eclipse.jst.jsf.common.internal.componentcore.AbstractVirtualComponentQuery.DefaultVirtualComponentQuery;
import org.eclipse.jst.jsf.core.IJSFCoreConstants;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.Messages;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.project.facet.core.IFacetedProject;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
/**
* JSFAppConfigUtils provides utility methods useful in processing of a JSF
* application configuration.
*
* <p><b>Provisional API - subject to change</b></p>
*
* @author Ian Trimble - Oracle
*/
public class JSFAppConfigUtils {
/**
* Name of JSF CONFIG_FILES context parameter ("javax.faces.CONFIG_FILES").
*/
public static final String CONFIG_FILES_CONTEXT_PARAM_NAME = "javax.faces.CONFIG_FILES"; //$NON-NLS-1$
/**
* Location in JAR file of application configuration resource file
* ("META-INF/faces-config.xml").
*/
public static final String FACES_CONFIG_IN_JAR_PATH = "META-INF/faces-config.xml"; //$NON-NLS-1$
/**
* @param project
* @param minVersion
* @return true if project is a JSF facet project and the version of the project
* is at least minVersion.
*/
public static boolean isValidJSFProject(IProject project, String minVersion)
{
boolean isValid = false;
final IProjectFacetVersion projectFacetVersion = getProjectFacet(project);
if (projectFacetVersion != null)
{
try
{
final String versionString =
projectFacetVersion.getVersionString();
final Comparator comparator =
projectFacetVersion.getProjectFacet().getVersionComparator();
final int compareToMin =
comparator.compare(versionString, minVersion);
if (compareToMin >=0)
{
return true;
}
}
catch (CoreException ce)
{
JSFCorePlugin.log(ce, "Error checking facet version"); //$NON-NLS-1$
}
}
return isValid;
}
/**
* Tests if the passed IProject instance is a valid JSF project in the
* following ways:
* <ul>
* <li>project is not null and is accessible, </li>
* <li>project has the JSF facet set on it.</li>
* </ul>
*
* @param project IProject instance to be tested.
* @return true if the IProject instance is a valid JSF project, else
* false.
*/
public static boolean isValidJSFProject(IProject project) {
boolean isValid = false;
IProjectFacetVersion projectFacet = getProjectFacet(project);
if (projectFacet != null)
{
isValid = true;
}
return isValid;
}
/**
* Get the facet version for the project
* @param project
* @return the project facet version or null if could not be found or if
* project is not accessible
*/
public static IProjectFacetVersion getProjectFacet(IProject project)
{
//check for null or inaccessible project
if (project != null && project.isAccessible()) {
//check for JSF facet on project
try {
IFacetedProject facetedProject = ProjectFacetsManager.create(project);
if (facetedProject != null) {
Set projectFacets = facetedProject.getProjectFacets();
Iterator itProjectFacets = projectFacets.iterator();
while (itProjectFacets.hasNext()) {
IProjectFacetVersion projectFacetVersion = (IProjectFacetVersion)itProjectFacets.next();
if (IJSFCoreConstants.JSF_CORE_FACET_ID.equals(projectFacetVersion.getProjectFacet().getId()))
{
return projectFacetVersion;
}
}
}
} catch(CoreException ce) {
//log error
JSFCorePlugin.log(IStatus.ERROR, ce.getLocalizedMessage(), ce);
}
}
return null;
}
/**
* Gets an IVirtualFolder instance which represents the root context's
* web content folder.
*
* @param project IProject instance for which to get the folder.
* @return IVirtualFolder instance which represents the root context's
* web content folder.
* @deprecated Call DefaultVirtualComponentQuery.getWebContentFolder instead
*/
public static IVirtualFolder getWebContentFolder(IProject project) {
return new DefaultVirtualComponentQuery().getWebContentFolder(project);
}
/**
* Gets an IPath instance representing the path of the passed IFile
* instance relative to the web content folder.
*
* @param file IFile instance for which a path is required.
* @return IPath instance representing the path relative to the web content
* folder.
*/
public static IPath getWebContentFolderRelativePath(IFile file) {
IPath path = null;
if (file != null) {
IVirtualFolder webContentFolder = getWebContentFolder(file.getProject());
if (webContentFolder != null) {
IPath webContentPath = webContentFolder.getProjectRelativePath();
IPath filePath = file.getProjectRelativePath();
int matchingFirstSegments = webContentPath.matchingFirstSegments(filePath);
path = filePath.removeFirstSegments(matchingFirstSegments);
}
}
return path;
}
/**
* Gets list of application configuration file names as listed in the JSF
* CONFIG_FILES context parameter ("javax.faces.CONFIG_FILES"). Will return
* an empty list if WebArtifactEdit is null, if WebApp is null, if context
* parameter does not exist, or if trimmed context parameter's value is
* an empty String.
*
* @param project IProject instance for which to get the context
* parameter's value.
* @return List of application configuration file names as listed in the
* JSF CONFIG_FILES context parameter ("javax.faces.CONFIG_FILES"); list
* may be empty.
*/
public static List getConfigFilesFromContextParam(IProject project) {
List filesList = Collections.EMPTY_LIST;
if (isValidJSFProject(project)) {
IModelProvider provider = ModelProviderManager.getModelProvider(project);
Object webAppObj = provider.getModelObject();
if (webAppObj != null){
if (webAppObj instanceof WebApp)
filesList = getConfigFilesForJ2EEApp(project);
else if (webAppObj instanceof org.eclipse.jst.javaee.web.WebApp)
filesList = getConfigFilesForJEEApp((org.eclipse.jst.javaee.web.WebApp)webAppObj);
}
}
return filesList;
}
private static List getConfigFilesForJEEApp(org.eclipse.jst.javaee.web.WebApp webApp) {
String filesString = null;
List contextParams = webApp.getContextParams();
Iterator itContextParams = contextParams.iterator();
while (itContextParams.hasNext()) {
org.eclipse.jst.javaee.core.ParamValue paramValue = (org.eclipse.jst.javaee.core.ParamValue)itContextParams.next();
if (paramValue.getParamName().equals(CONFIG_FILES_CONTEXT_PARAM_NAME)) {
filesString = paramValue.getParamValue();
break;
}
}
return parseFilesString(filesString);
}
private static List getConfigFilesForJ2EEApp(IProject project){
List filesList = new ArrayList();
WebArtifactEdit webArtifactEdit = WebArtifactEdit.getWebArtifactEditForRead(project);
if (webArtifactEdit != null) {
try {
WebApp webApp = null;
try {
webApp = webArtifactEdit.getWebApp();
} catch(ClassCastException cce) {
//occasionally thrown from WTP code in RC3 and possibly later
JSFCorePlugin.log(IStatus.ERROR, cce.getLocalizedMessage(), cce);
return filesList;
}
if (webApp != null) {
String filesString = null;
//need to branch here due to model version differences (BugZilla #119442)
if (webApp.getVersionID() == J2EEVersionConstants.WEB_2_3_ID) {
EList contexts = webApp.getContexts();
Iterator itContexts = contexts.iterator();
while (itContexts.hasNext()) {
ContextParam contextParam = (ContextParam)itContexts.next();
if (contextParam.getParamName().equals(CONFIG_FILES_CONTEXT_PARAM_NAME)) {
filesString = contextParam.getParamValue();
break;
}
}
} else {
EList contextParams = webApp.getContextParams();
Iterator itContextParams = contextParams.iterator();
while (itContextParams.hasNext()) {
ParamValue paramValue = (ParamValue)itContextParams.next();
if (paramValue.getName().equals(CONFIG_FILES_CONTEXT_PARAM_NAME)) {
filesString = paramValue.getValue();
break;
}
}
}
filesList = parseFilesString(filesString);
}
} finally {
webArtifactEdit.dispose();
}
}
return filesList;
}
private static List parseFilesString(String filesString) {
List filesList = new ArrayList();
if (filesString != null && filesString.trim().length() > 0) {
StringTokenizer stFilesString = new StringTokenizer(filesString, ","); //$NON-NLS-1$
while (stFilesString.hasMoreTokens()) {
String configFile = stFilesString.nextToken().trim();
filesList.add(configFile);
}
}
return filesList;
}
/**
* Gets list of JAR file names, where each file name represents a JAR on
* the classpath that contains a /META-INF/faces-config.xml entry. Will
* return an empty list if no such JAR files are located.
*
* @param project IProject instance for which to scan the classpath.
* @return List of JAR file names, where each file name represents a JAR
* on the classpath that contains a ...META-INF/faces-config.xml entry;
* list may be empty.
* @throws CoreException Thrown when underlying calls into JavaCore fail.
* @throws IOException Thrown when attempt to open JAR to determine if it
* contains a /META-INF/faces-config.xml entry fails.
*/
public static List getConfigFileJARsFromClasspath(IProject project) throws CoreException, IOException {
ArrayList JARsList = new ArrayList();
if (project.isAccessible()
&& project.hasNature(JavaCore.NATURE_ID)) {
IJavaProject javaProject = JavaCore.create(project);
if (javaProject != null) {
IClasspathEntry[] classpathEntries = javaProject.getResolvedClasspath(true);
if (classpathEntries != null && classpathEntries.length > 0) {
IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
for (int i = 0; i < classpathEntries.length; i++) {
IClasspathEntry classpathEntry = classpathEntries[i];
if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
IPath libraryPath = classpathEntry.getPath();
if (libraryPath.getFileExtension() != null && libraryPath.getFileExtension().length() > 0) {
if (libraryPath.getDevice() == null && workspaceRoot.getProject(libraryPath.segment(0)).exists()) {
libraryPath = workspaceRoot.getFile(libraryPath).getLocation();
}
String libraryPathString = libraryPath.toString();
JarFile jarFile = null;
try {
//check existence first [222249]
File file = new File(libraryPathString);
if (file.exists()) {
jarFile = new JarFile(file, false);
if (jarFile != null) {
JarEntry jarEntry = jarFile.getJarEntry(FACES_CONFIG_IN_JAR_PATH);
if (jarEntry != null) {
JARsList.add(libraryPathString);
}
}
}
} catch (FileNotFoundException fnfex) {
//should not get here, but eat error since this could only occur in under strange circumstances [222249]
} catch(IOException ioe) {
JSFCorePlugin.log(
IStatus.ERROR,
NLS.bind(Messages.JSFAppConfigUtils_ErrorOpeningJarFile, libraryPathString),
ioe);
} finally {
if (jarFile != null) {
jarFile.close();
}
}
}
}
}
}
}
}
return JARsList;
}
}