| /******************************************************************************* |
| * 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); |
| } |
| } |
