/*******************************************************************************
* Copyright (c) 2003, 2007 IBM Corporation and others.
* 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.j2ee.internal.project;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jem.java.JavaClass;
import org.eclipse.jem.java.JavaRefFactory;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jem.workbench.utility.JemProjectUtilities;
import org.eclipse.jst.common.internal.modulecore.util.ManifestUtilities;
import org.eclipse.jst.common.jdt.internal.javalite.IJavaProjectLite;
import org.eclipse.jst.common.jdt.internal.javalite.JavaCoreLite;
import org.eclipse.jst.common.jdt.internal.javalite.JavaLiteUtilities;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonarchiveFactory;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EJBJarFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.DeploymentDescriptorLoadException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifestImpl;
import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
import org.eclipse.jst.j2ee.ejb.EJBJar;
import org.eclipse.jst.j2ee.ejb.EnterpriseBean;
import org.eclipse.jst.j2ee.internal.J2EEConstants;
import org.eclipse.jst.j2ee.internal.archive.operations.JavaComponentLoadStrategyImpl;
import org.eclipse.jst.j2ee.internal.common.classpath.J2EEComponentClasspathUpdater;
import org.eclipse.jst.j2ee.internal.componentcore.JavaEEBinaryComponentHelper;
import org.eclipse.jst.j2ee.internal.moduleextension.EarModuleManager;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.j2ee.project.EarUtilities;
import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetConstants;
import org.eclipse.jst.j2ee.project.facet.IJavaProjectMigrationDataModelProperties;
import org.eclipse.jst.j2ee.project.facet.JavaProjectMigrationDataModelProvider;
import org.eclipse.jst.j2ee.project.facet.JavaProjectMigrationOperation;
import org.eclipse.jst.jee.archive.IArchive;
import org.eclipse.jst.jee.archive.IArchiveResource;
import org.eclipse.jst.server.core.FacetUtil;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
import org.eclipse.wst.common.frameworks.internal.SimpleValidateEdit;
import org.eclipse.wst.common.project.facet.core.IFacetedProject;
import org.eclipse.wst.common.project.facet.core.IProjectFacet;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
import org.eclipse.wst.server.core.IRuntime;
public class J2EEProjectUtilities extends ProjectUtilities implements IJ2EEFacetConstants {
/**
* Return the absolute path of a loose archive in a J2EE application or WAR file
*/
public static IPath getRuntimeLocation(IProject aProject) {
if (JemProjectUtilities.isBinaryProject(aProject))
return getBinaryProjectJARLocation(aProject);
return JemProjectUtilities.getJavaProjectOutputAbsoluteLocation(aProject);
}
public static IPath getBinaryProjectJARLocation(IProject aProject) {
List sources = JemProjectUtilities.getLocalJARPathsFromClasspath(aProject);
if (!sources.isEmpty()) {
IPath path = (IPath) sources.get(0);
return aProject.getFile(path).getLocation();
}
return null;
}
public static Archive getClientJAR(EJBJarFile file, EARFile earFile) {
EJBJar jar = null;
try {
jar = file.getDeploymentDescriptor();
} catch (DeploymentDescriptorLoadException exc) {
return null;
}
if (jar == null)
return null;
String clientJAR = jar.getEjbClientJar();
if (clientJAR == null || clientJAR.length() == 0)
return null;
String normalized = ArchiveUtil.deriveEARRelativeURI(clientJAR, file.getURI());
if (normalized != null) {
try {
File aFile = earFile.getFile(normalized);
if (aFile.isArchive() && !aFile.isModuleFile())
return (Archive) aFile;
} catch (FileNotFoundException nothingThere) {
}
}
return null;
// TODO - release the DD here to free up space
}
/**
* Append one IClasspathEntry to the build path of the passed project. If a classpath entry
* having the same path as the parameter already exists, then does nothing.
*/
public static void appendJavaClassPath(IProject p, IClasspathEntry newEntry) throws JavaModelException {
IJavaProject javaProject = JemProjectUtilities.getJavaProject(p);
if (javaProject == null)
return;
IClasspathEntry[] classpath = javaProject.getRawClasspath();
List newPathList = new ArrayList(classpath.length);
for (int i = 0; i < classpath.length; i++) {
IClasspathEntry entry = classpath[i];
// fix dup class path entry for .JETEmitter project
// Skip the entry to be added if it already exists
if (Platform.getOS().equals(Platform.OS_WIN32)) {
if (!entry.getPath().toString().equalsIgnoreCase(newEntry.getPath().toString()))
newPathList.add(entry);
else
return;
} else {
if (!entry.getPath().equals(newEntry.getPath()))
newPathList.add(entry);
else
return;
}
}
newPathList.add(newEntry);
IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList.toArray(new IClasspathEntry[newPathList.size()]);
javaProject.setRawClasspath(newClasspath, new NullProgressMonitor());
}
public static Archive asArchiveFromBinary(String jarUri, IProject aProject) throws OpenFailureException {
IPath path = getBinaryProjectJARLocation(aProject);
if (path != null) {
String location = path.toOSString();
Archive anArchive = CommonarchiveFactory.eINSTANCE.primOpenArchive(location);
anArchive.setURI(jarUri);
return anArchive;
}
return null;
}
/**
* @deprecated Use org.eclipse.jst.common.internal.modulecore.util.ManifestUtilities instead
* @param aFile
* @return
*/
public static ArchiveManifest readManifest(IFile aFile) {
InputStream in = null;
try {
if (aFile == null || !aFile.exists())
return null;
in = aFile.getContents();
return new ArchiveManifestImpl(in);
} catch (Exception ex) {
J2EEPlugin.logError(ex);
return null;
} finally {
if (in != null) {
try {
in.close();
} catch (IOException weTried) {
}
}
}
}
public static ArchiveManifest readManifest(IProject p) {
InputStream in = null;
try {
IFile aFile = getManifestFile(p);
if (aFile == null || !aFile.exists())
return null;
in = aFile.getContents();
return new ArchiveManifestImpl(in);
} catch (Exception ex) {
J2EEPlugin.logError(ex);
return null;
} finally {
if (in != null) {
try {
in.close();
} catch (IOException weTried) {
}
}
}
}
/**
* Equavalent to calling getManifestFile(project, true)
*
* @param p
* @return
*/
public static IFile getManifestFile(IProject project) {
return getManifestFile(project, true);
}
/**
* Returns the IFile handle to the J2EE manifest file for the specified
* project. If createIfNecessary is true, the MANIFEST.MF file will be
* created if it does not already exist.
*
* @param p
* @param createIfNecessary
* @return
*/
public static IFile getManifestFile(IProject p, boolean createIfNecessary) {
IVirtualComponent component = ComponentCore.createComponent(p);
try {
IFile file = ComponentUtilities.findFile(component, new Path(J2EEConstants.MANIFEST_URI));
if (createIfNecessary && file == null) {
IVirtualFolder virtualFolder = component.getRootFolder();
file = virtualFolder.getUnderlyingFolder().getFile(new Path(J2EEConstants.MANIFEST_URI));
try {
ManifestFileCreationAction.createManifestFile(file, p);
} catch (CoreException e) {
J2EEPlugin.logError(e);
} catch (IOException e) {
J2EEPlugin.logError(e);
}
}
return file;
} catch (CoreException ce) {
J2EEPlugin.logError(ce);
}
return null;
}
public static void writeManifest(IProject aProject, ArchiveManifest manifest) throws java.io.IOException {
writeManifest(aProject, getManifestFile(aProject), manifest);
}
public static void writeManifest(IFile aFile, ArchiveManifest manifest) throws java.io.IOException {
writeManifest(aFile.getProject(), aFile, manifest);
}
private static void writeManifest(IProject aProject, IFile aFile, ArchiveManifest manifest) throws java.io.IOException {
if (aFile != null) {
if(SimpleValidateEdit.validateEdit(new IFile[] { aFile })){
ManifestUtilities.writeManifest(aFile, manifest);
J2EEComponentClasspathUpdater.getInstance().queueUpdateModule(aProject);
}
}
}
public static ArchiveManifest readManifest(IVirtualComponent component) {
if (!component.isBinary()) {
IVirtualFile vManifest = component.getRootFolder().getFile(J2EEConstants.MANIFEST_URI);
if (vManifest.exists()) {
IFile manifestFile = vManifest.getUnderlyingFile();
InputStream in = null;
try {
in = manifestFile.getContents();
return new ArchiveManifestImpl(in);
} catch (IOException e) {
J2EEPlugin.logError(e);
} catch (CoreException e) {
J2EEPlugin.logError(e);
} finally {
if (in != null) {
try {
in.close();
in = null;
} catch (IOException e) {
J2EEPlugin.logError(e);
}
}
}
}
} else {
JavaEEBinaryComponentHelper helper = null;
try{
helper = new JavaEEBinaryComponentHelper(component);
IArchive archive = null;
InputStream in = null;
try{
archive = helper.accessArchive();
if(null != archive){
IPath manifestPath = new Path(J2EEConstants.MANIFEST_URI);
if(archive.containsArchiveResource(manifestPath)){
IArchiveResource manifestResource = archive.getArchiveResource(manifestPath);
if(manifestResource != null){
in = manifestResource.getInputStream();
ArchiveManifest manifest = new ArchiveManifestImpl(in);
return manifest;
}
}
}
} catch (FileNotFoundException e) {
J2EEPlugin.logError(e);
} catch (IOException e) {
J2EEPlugin.logError(e);
} finally{
if (in != null) {
try {
in.close();
in = null;
} catch (IOException e) {
J2EEPlugin.logError(e);
}
}
if(archive != null){
helper.releaseArchive(archive);
}
}
} finally{
if(helper != null){
helper.dispose();
}
}
}
return null;
}
/**
* Keys are the EJB JAR files and the values are the respective client JARs; includes only key
* value pairs for which EJB Client JARs are defined and exist.
*
* @author schacher
*/
public static Map collectEJBClientJARs(EARFile earFile) {
if (earFile == null)
return Collections.EMPTY_MAP;
Map ejbClientJARs = null;
List ejbJARFiles = earFile.getEJBJarFiles();
Archive clientJAR = null;
for (int i = 0; i < ejbJARFiles.size(); i++) {
EJBJarFile ejbJarFile = (EJBJarFile) ejbJARFiles.get(i);
clientJAR = getClientJAR(ejbJarFile, earFile);
if (clientJAR != null) {
if (ejbClientJARs == null)
ejbClientJARs = new HashMap();
ejbClientJARs.put(ejbJarFile, clientJAR);
}
}
return ejbClientJARs == null ? Collections.EMPTY_MAP : ejbClientJARs;
}
public static String computeRelativeText(String referencingURI, String referencedURI, EnterpriseBean bean) {
if (bean == null)
return null;
String beanName = bean.getName();
if (beanName == null)
return null;
String relativeUri = computeRelativeText(referencingURI, referencedURI);
if (relativeUri == null)
return beanName;
return relativeUri + "#" + beanName; //$NON-NLS-1$
}
public static String computeRelativeText(String referencingURI, String referencedURI) {
if (referencingURI == null || referencedURI == null)
return null;
IPath pPre = new Path(referencingURI);
IPath pDep = new Path(referencedURI);
if (pPre.getDevice() != null || pDep.getDevice() != null)
return null;
pPre = pPre.makeRelative();
pDep = pDep.makeRelative(); // referenced Archive path URI
while (pPre.segmentCount() > 1 && pDep.segmentCount() > 1 && pPre.segment(0).equals(pDep.segment(0))) {
pPre = pPre.removeFirstSegments(1);
pDep = pDep.removeFirstSegments(1);
}
IPath result = null;
StringBuffer buf = new StringBuffer();
String segment = null;
do {
segment = pDep.lastSegment();
pPre = pPre.removeLastSegments(1);
pDep = pDep.removeLastSegments(1);
if (segment != null) {
if (result == null)
result = new Path(segment);
else
result = new Path(segment).append(result);
}
if (!pPre.equals(pDep) && !pPre.isEmpty())
buf.append("../"); //$NON-NLS-1$
} while (!pPre.equals(pDep));
if (result != null)
buf.append(result.makeRelative().toString());
return buf.toString();
}
public static IProject getEJBProjectFromEJBClientProject(IProject ejbClientProject) {
try {
if (null != ejbClientProject && ejbClientProject.hasNature(JavaCore.NATURE_ID)) {
IProject[] allProjects = getAllProjects();
for (int i = 0; i < allProjects.length; i++) {
if (null != EarModuleManager.getEJBModuleExtension().getEJBJar(allProjects[i])) {
if (ejbClientProject == EarModuleManager.getEJBModuleExtension().getDefinedEJBClientJARProject(allProjects[i])) {
return allProjects[i];
}
}
}
}
} catch (CoreException e) {
}
return null;
}
public static EnterpriseBean getEnterpriseBean(ICompilationUnit cu) {
IProject proj = cu.getJavaProject().getProject();
EJBJar jar = EarModuleManager.getEJBModuleExtension().getEJBJar(proj);
if (null == jar) {
jar = EarModuleManager.getEJBModuleExtension().getEJBJar(getEJBProjectFromEJBClientProject(proj));
}
if (jar != null) {
int index = cu.getElementName().indexOf('.');
String className = cu.getElementName();
if (index > 0)
className = className.substring(0, index);
JavaClass javaClass = (JavaClass) JavaRefFactory.eINSTANCE.reflectType(cu.getParent().getElementName(), className, jar.eResource().getResourceSet());
return jar.getEnterpriseBeanWithReference(javaClass);
}
return null;
}
public static IContainer getSourceFolderOrFirst(IProject p, String defaultSourceName) {
try {
IPath sourcePath = getSourcePathOrFirst(p, defaultSourceName);
if (sourcePath == null)
return null;
else if (sourcePath.isEmpty())
return p;
else
return p.getFolder(sourcePath);
} catch (IllegalArgumentException ex) {
return null;
}
}
public static void removeBuilders(IProject project, List builderids) throws CoreException {
IProjectDescription desc = project.getDescription();
ICommand[] oldSpec = desc.getBuildSpec();
int oldLength = oldSpec.length;
if (oldLength == 0)
return;
int remaining = 0;
// null out all commands that match the builder to remove
for (int i = 0; i < oldSpec.length; i++) {
if (builderids.contains(oldSpec[i].getBuilderName()))
oldSpec[i] = null;
else
remaining++;
}
// check if any were actually removed
if (remaining == oldSpec.length)
return;
ICommand[] newSpec = new ICommand[remaining];
for (int i = 0, newIndex = 0; i < oldLength; i++) {
if (oldSpec[i] != null)
newSpec[newIndex++] = oldSpec[i];
}
desc.setBuildSpec(newSpec);
project.setDescription(desc, IResource.NONE, null);
}
public static IPath getSourcePathOrFirst(IProject p, String defaultSourceName) {
IJavaProject javaProj = JemProjectUtilities.getJavaProject(p);
if (javaProj == null)
return null;
IClasspathEntry[] cp = null;
try {
cp = javaProj.getRawClasspath();
} catch (JavaModelException ex) {
J2EEPlugin.logError(ex);
return null;
}
IClasspathEntry firstSource = null;
IPath defaultSourcePath = null;
if (defaultSourceName != null)
defaultSourcePath = createPath(p, defaultSourceName);
boolean found = false;
for (int i = 0; i < cp.length; i++) {
if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
// check if it contains /META-INF/MANIFEST.MF
IPath sourceFolderPath = cp[i].getPath().removeFirstSegments(1);
IFolder sourceFolder = p.getFolder(sourceFolderPath);
if (isSourceFolderAnInputContainer(sourceFolder)) {
found = true;
if (firstSource == null) {
firstSource = cp[i];
if (defaultSourcePath == null)
break;
}
if (cp[i].getPath().equals(defaultSourcePath) && defaultSourcePath != null)
return defaultSourcePath.removeFirstSegments(1);
}
}
}
if (!found) {
for (int i = 0; i < cp.length; i++) {
if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
if (firstSource == null) {
firstSource = cp[i];
if (defaultSourcePath == null)
break;
}
if (cp[i].getPath().equals(defaultSourcePath) && defaultSourcePath != null)
return defaultSourcePath.removeFirstSegments(1);
}
}
}
if (firstSource == null)
return null;
if (firstSource.getPath().segment(0).equals(p.getName()))
return firstSource.getPath().removeFirstSegments(1);
return null;
}
public static boolean isSourceFolderAnInputContainer(IFolder sourceFolder) {
IContainer parent = sourceFolder;
while (true) {
parent = parent.getParent();
if (parent == null)
return false;
if (parent instanceof IProject)
break;
}
IProject project = (IProject) parent;
try {
if (!project.isAccessible())
return false;
if (JavaEEProjectUtilities.isEJBProject(project)) {
return sourceFolder.findMember(J2EEConstants.EJBJAR_DD_URI) != null;
} else if (JavaEEProjectUtilities.isApplicationClientProject(project)) {
return sourceFolder.findMember(J2EEConstants.APP_CLIENT_DD_URI) != null;
} else if (JavaEEProjectUtilities.isDynamicWebProject(project)) {
return sourceFolder.findMember(J2EEConstants.WEBAPP_DD_URI) != null;
} else if (JavaEEProjectUtilities.isJCAProject(project)) {
return sourceFolder.findMember(J2EEConstants.RAR_DD_URI) != null;
}
} catch (Exception e) {
J2EEPlugin.logError(e);
}
return false;
}
public static Archive asArchive(String jarUri, IProject project, boolean exportSource) throws OpenFailureException {
return asArchive(jarUri, project, exportSource, true);
}
public static Archive asArchive(String jarUri, IProject project, boolean exportSource, boolean includeClasspathComponents) throws OpenFailureException {
JavaComponentLoadStrategyImpl strat = new JavaComponentLoadStrategyImpl(ComponentCore.createComponent(project), includeClasspathComponents);
strat.setExportSource(exportSource);
return CommonarchiveFactory.eINSTANCE.primOpenArchive(strat, jarUri);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isProjectOfType(IProject project, String typeID)}
*/
public static boolean isProjectOfType(IProject project, String typeID) {
return JavaEEProjectUtilities.isProjectOfType(project,typeID);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isEARProject(IProject project)}
*/
public static boolean isEARProject(IProject project) {
return JavaEEProjectUtilities.isEARProject(project);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isDynamicWebComponent(IVirtualComponent component)}
*/
public static boolean isDynamicWebComponent(IVirtualComponent component) {
return JavaEEProjectUtilities.isDynamicWebComponent(component);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isDynamicWebProject(IProject project)}
*/
public static boolean isDynamicWebProject(IProject project) {
return JavaEEProjectUtilities.isDynamicWebProject(project);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isStaticWebProject(IProject project)}
*/
public static boolean isStaticWebProject(IProject project) {
return JavaEEProjectUtilities.isStaticWebProject(project);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isEJBComponent(IVirtualComponent component)}
*/
public static boolean isEJBComponent(IVirtualComponent component) {
return JavaEEProjectUtilities.isEJBComponent(component);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isEJBProject(IProject project)}
*/
public static boolean isEJBProject(IProject project) {
return JavaEEProjectUtilities.isEJBProject(project);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isJCAComponent(IVirtualComponent component)}
*/
public static boolean isJCAComponent(IVirtualComponent component) {
return JavaEEProjectUtilities.isJCAComponent(component);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isJCAProject(IProject project)}
*/
public static boolean isJCAProject(IProject project) {
return JavaEEProjectUtilities.isJCAProject(project);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isApplicationClientComponent(IVirtualComponent component)}
*/
public static boolean isApplicationClientComponent(IVirtualComponent component) {
return JavaEEProjectUtilities.isApplicationClientComponent(component);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isApplicationClientProject(IProject project)}
*/
public static boolean isApplicationClientProject(IProject project) {
return JavaEEProjectUtilities.isApplicationClientProject(project);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.isUtilityProject(IProject project)}
*/
public static boolean isUtilityProject(IProject project) {
return JavaEEProjectUtilities.isUtilityProject(project);
}
/**
* @deprecated - see {@link EarUtilities.isStandaloneProject(IProject project)}
*/
public static boolean isStandaloneProject(IProject project) {
return EarUtilities.isStandaloneProject(project);
}
/**
* @deprecated use {@link EarUtilities#getReferencingEARProjects(IProject)}
*
*/
public static IProject[] getReferencingEARProjects(final IProject project) {
return EarUtilities.getReferencingEARProjects(project);
}
/**
* Returns all referencing dynamic web projects.
* @param project Project to check. If null or a dynamic web project, returns a zero length array.
* @return Array of referencing dynamic web projects.
*/
public static IProject[] getReferencingWebProjects(final IProject project) {
if(project != null && JavaEEProjectUtilities.isDynamicWebProject(project)){
return new IProject[] {project};
}
List result = new ArrayList();
IVirtualComponent component = ComponentCore.createComponent(project);
if (component != null) {
IVirtualComponent[] refComponents = component.getReferencingComponents();
for (int i = 0; i < refComponents.length; i++) {
if (JavaEEProjectUtilities.isDynamicWebProject(refComponents[i].getProject()))
result.add(refComponents[i].getProject());
}
}
return (IProject[]) result.toArray(new IProject[result.size()]);
}
/**
* Return all projects in workspace of the specified type
*
* @param type -
* use one of the static strings on this class as a type
* @return IProject[]
* @deprecated - see {@link JavaEEProjectUtilities.getAllProjectsInWorkspaceOfType(String type)}
*/
public static IProject[] getAllProjectsInWorkspaceOfType(String type) {
return JavaEEProjectUtilities.getAllProjectsInWorkspaceOfType(type);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.getJ2EEComponentType(IVirtualComponent component)}
*/
public static String getJ2EEComponentType(IVirtualComponent component) {
return JavaEEProjectUtilities.getJ2EEComponentType(component);
}
/**
* @deprecated - see {@link JavaEEProjectUtilities.getJ2EEProjectType(IProject project)}
*/
public static String getJ2EEProjectType(IProject project) {
return JavaEEProjectUtilities.getJ2EEProjectType(project);
}
/**
* Returns the J2EE Module version based on the DD XML file
* @param project
* @return version String
* @deprecated - see {@link JavaEEProjectUtilities.getJ2EEDDProjectVersion(IProject project)}
*/
public static String getJ2EEDDProjectVersion(IProject project) {
return JavaEEProjectUtilities.getJ2EEDDProjectVersion(project);
}
public static IRuntime getServerRuntime(IProject project) throws CoreException {
if (project == null)
return null;
IFacetedProject facetedProject = ProjectFacetsManager.create(project);
if (facetedProject == null)
return null;
org.eclipse.wst.common.project.facet.core.runtime.IRuntime runtime = facetedProject.getRuntime();
if (runtime == null)
return null;
return FacetUtil.getRuntime(runtime);
}
/**
* Returns the J2EE Module version based on the project Facet installed
* @param project
* @return version String
*/
public static String getJ2EEProjectVersion(IProject project) {
String type = getJ2EEProjectType(project);
IFacetedProject facetedProject = null;
IProjectFacet facet = null;
try {
facetedProject = ProjectFacetsManager.create(project);
facet = ProjectFacetsManager.getProjectFacet(type);
} catch (Exception e) {
// Not Faceted project or not J2EE Project
}
if (facet != null && facetedProject != null && facetedProject.hasProjectFacet(facet))
return facetedProject.getInstalledVersion(facet).getVersionString();
return null;
}
public static JavaProjectMigrationOperation createFlexJavaProjectForProjectOperation(IProject project) {
IDataModel model = DataModelFactory.createDataModel(new JavaProjectMigrationDataModelProvider());
model.setProperty(IJavaProjectMigrationDataModelProperties.PROJECT_NAME, project.getName());
return new JavaProjectMigrationOperation(model);
}
public static JavaProjectMigrationOperation createFlexJavaProjectForProjectOperation(IProject project, boolean addToEAR) {
IDataModel model = DataModelFactory.createDataModel(new JavaProjectMigrationDataModelProvider());
model.setProperty(IJavaProjectMigrationDataModelProperties.PROJECT_NAME, project.getName());
model.setBooleanProperty(IJavaProjectMigrationDataModelProperties.ADD_TO_EAR, addToEAR);
return new JavaProjectMigrationOperation(model);
}
/**
* @deprecated use {@link JavaLiteUtilities#getJavaSourceContainers(IVirtualComponent)}
* @param project
* @return
*/
public static IPackageFragmentRoot[] getSourceContainers(IProject project) {
IJavaProject jProject = JemProjectUtilities.getJavaProject(project);
if (jProject == null)
return new IPackageFragmentRoot[0];
List list = new ArrayList();
IVirtualComponent vc = ComponentCore.createComponent(project);
IPackageFragmentRoot[] roots;
try {
roots = jProject.getPackageFragmentRoots();
for (int i = 0; i < roots.length; i++) {
if (roots[i].getKind() != IPackageFragmentRoot.K_SOURCE)
continue;
IResource resource = roots[i].getResource();
if (null != resource) {
IVirtualResource[] vResources = ComponentCore.createResources(resource);
boolean found = false;
for (int j = 0; !found && j < vResources.length; j++) {
if (vResources[j].getComponent().equals(vc)) {
if (!list.contains(roots[i]))
list.add(roots[i]);
found = true;
}
}
}
}
} catch (JavaModelException e) {
J2EEPlugin.logError(e);
}
return (IPackageFragmentRoot[]) list.toArray(new IPackageFragmentRoot[list.size()]);
}
/**
* @deprecated use {@link JavaLiteUtilities#getJavaOutputContainers(IVirtualComponent)}
* @param project
* @return
*/
public static IContainer[] getOutputContainers(IProject project) {
IVirtualComponent virtualComponent = ComponentCore.createComponent(project);
List <IContainer> containers = JavaLiteUtilities.getJavaOutputContainers(virtualComponent);
return containers.toArray(new IContainer[containers.size()]);
}
/**
* @deprecated use {@link JavaLiteUtilities#getJavaOutputContainer(IJavaProjectLite, IClasspathEntry)}
*
* {@link #getJavaOutputContainer(IJavaProjectLite, IClasspathEntry)}
* @param project
* @param sourceContainer
* @return
*/
public static IContainer getOutputContainer(IProject project, IPackageFragmentRoot sourceContainer) {
try {
return JavaLiteUtilities.getJavaOutputContainer(JavaCoreLite.create(project), sourceContainer.getRawClasspathEntry());
} catch (JavaModelException e) {
org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
}
return null;
}
/**
* @deprecated use {@link JavaLiteUtilities#getJavaOutputContainers(IVirtualComponent)}
* @param project
* @return
*/
public static IContainer[] getAllOutputContainers(IProject project) {
return getOutputContainers(project);
}
/**
*
* @param name
* @return
* @description the passed name should have either lib or var as its first segment e.g.
* lib/D:/foo/foo.jar or var/<CLASSPATHVAR>/foo.jar
*/
public static IPath getResolvedPathForArchiveComponent(String name) {
URI uri = URI.createURI(name);
String resourceType = uri.segment(0);
URI contenturi = ModuleURIUtil.trimToRelativePath(uri, 1);
String contentName = contenturi.toString();
if (resourceType.equals("lib")) { //$NON-NLS-1$
// module:/classpath/lib/D:/foo/foo.jar
return Path.fromOSString(contentName);
} else if (resourceType.equals("var")) { //$NON-NLS-1$
// module:/classpath/var/<CLASSPATHVAR>/foo.jar
String classpathVar = contenturi.segment(0);
URI remainingPathuri = ModuleURIUtil.trimToRelativePath(contenturi, 1);
String remainingPath = remainingPathuri.toString();
String[] classpathvars = JavaCore.getClasspathVariableNames();
boolean found = false;
for (int i = 0; i < classpathvars.length; i++) {
if (classpathVar.equals(classpathvars[i])) {
found = true;
break;
}
}
if (found) {
IPath path = JavaCore.getClasspathVariable(classpathVar);
if (path != null ){
URI finaluri = URI.createURI(path.toOSString() + IPath.SEPARATOR + remainingPath);
return Path.fromOSString(finaluri.toString());
}
}
}
return null;
}
public static List getAllJavaNonFlexProjects() throws CoreException {
List nonFlexJavaProjects = new ArrayList();
IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
for (int i = 0; i < projects.length; i++) {
if (projects[i].isAccessible() && projects[i].hasNature(JavaCore.NATURE_ID) && !projects[i].hasNature(IModuleConstants.MODULE_NATURE_ID)) {
nonFlexJavaProjects.add(projects[i]);
}
}
return nonFlexJavaProjects;
}
/**
* This method will retrieve the context root for the associated workbench module which is used
* by the server at runtime. This method is not yet completed as the context root has to be
* abstracted and added to the workbenchModule model. This API will not change though. Returns
* null for now.
*
* @return String value of the context root for runtime of the associated module
*/
public static String getServerContextRoot(IProject project) {
return ComponentUtilities.getServerContextRoot(project);
}
/**
* This method will set the context root on the associated workbench module with the given
* string value passed in. This context root is used by the server at runtime. This method is
* not yet completed as the context root still needs to be abstracted and added to the workbench
* module model. This API will not change though. Does nothing as of now.
*
* @param contextRoot
* string
*/
public static void setServerContextRoot(IProject project, String contextRoot) {
ComponentUtilities.setServerContextRoot(project, contextRoot);
}
/**
* @param project
* @return true, if jee version 5.0 or later (or their respective ejb, web, app versions)
* , it must be noted that this method only looks at the facet & their versions to determine
* the jee level. It does not read deployment descriptors for performance reasons.
*/
public static boolean isJEEProject(IProject project){
IVirtualComponent component = ComponentCore.createComponent(project);
if(component != null)
return JavaEEProjectUtilities.isJEEComponent(component);
return false;
}
/**
* @param project
* @return true, if j2ee version 1.2, 1.3, 1.4 (or their respective ejb, web, app versions)
* , it must be noted that this method only looks at the facet & their versions to determine
* the j2ee level. It does not read deployment descriptors for performance reasons.
* @deprecated use JavaEEProjectUtilities.isLegacyJ2EEComponent(etc)
*/
public static boolean isLegacyJ2EEProject(IProject project){
IVirtualComponent component = ComponentCore.createComponent(project);
if(component != null)
return JavaEEProjectUtilities.isLegacyJ2EEComponent(component);
return false;
}
/**
* This method will return the an IVirtualComponent for the given module name. The method take
* either moduleName or moduleName + ".module_extension" (module_extension = ".jar" || ".war" ||
* ".rar") which allows users to get a IVirtualComponent for a given entry in an application.xml
*
* @return - a IVirtualComponent for module name
* @deprecated - see {@link EarUtilities.getModule(IVirtualComponent earComponent, String moduleName)}
*/
public static IVirtualComponent getModule(IVirtualComponent earComponent, String moduleName) {
return EarUtilities.getModule(earComponent, moduleName);
}
/**
* This method will return the list of IVirtualReferences for the J2EE module components
* contained in this EAR application.
*
* @return - an array of IVirtualReferences for J2EE modules in the EAR
* @deprecated - see {@link EarUtilities.getJ2EEModuleReferences(IVirtualComponent earComponent)}
*/
public static IVirtualReference[] getJ2EEModuleReferences(IVirtualComponent earComponent) {
return EarUtilities.getJ2EEModuleReferences(earComponent);
}
/**
* This method will return the list of IVirtualReferences for all of the components contained in
* an EAR application.
*
* @return - an array of IVirtualReferences for components in the EAR
* @deprecated - see {@link EarUtilities.getComponentReferences(IVirtualComponent earComponent)}
*/
public static IVirtualReference[] getComponentReferences(IVirtualComponent earComponent) {
return EarUtilities.getComponentReferences(earComponent);
}
/**
* This method will return the IVirtualReference to the component of the given name
*
* @return - IVirtualReference or null if not found
* @deprecated - see {@link EarUtilities.getComponentReference(IVirtualComponent earComponent, String componentName)}
*/
public static IVirtualReference getComponentReference(IVirtualComponent earComponent, String componentName) {
return EarUtilities.getComponentReference(earComponent, componentName);
}
}