| /********************************************************************* |
| * Copyright (c) 2009 - 2012 SpringSource, a division of VMware, Inc. |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| **********************************************************************/ |
| |
| package org.eclipse.virgo.ide.manifest.core; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.io.Writer; |
| import java.net.URI; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.Dictionary; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.commons.lang.StringUtils; |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IPathVariableManager; |
| import org.eclipse.core.resources.IProject; |
| 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.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit; |
| import org.eclipse.osgi.util.ManifestElement; |
| import org.eclipse.virgo.ide.facet.core.FacetCorePlugin; |
| import org.eclipse.virgo.ide.facet.core.FacetUtils; |
| import org.eclipse.virgo.ide.manifest.internal.core.model.BundleManifestHeader; |
| import org.eclipse.virgo.ide.module.core.ServerModuleDelegate; |
| import org.eclipse.virgo.util.osgi.manifest.BundleManifest; |
| import org.eclipse.virgo.util.osgi.manifest.BundleManifestFactory; |
| import org.eclipse.wst.common.project.facet.core.FacetedProjectFramework; |
| import org.osgi.framework.Constants; |
| |
| /** |
| * Helper methods to located and load {@link BundleManifest} instances. |
| * |
| * @author Christian Dupuis |
| * @author Steffen Pingel |
| * @author Martin Lippert |
| * @since 1.0.0 |
| */ |
| public class BundleManifestUtils { |
| |
| /** URL file schema */ |
| private static final String FILE_SCHEME = "file"; |
| |
| /** |
| * Returns a {@link BundleManifest} instance for the given <code>javaProject</code>. |
| * <p> |
| * This implementation searches the source folders of the {@link IJavaProject} and returns the first found |
| * META-INF/MANIFEST.MF as the valid manifest. |
| */ |
| public static BundleManifest getBundleManifest(IJavaProject javaProject, boolean testBundle) { |
| IFile manifestFile = locateManifest(javaProject, testBundle); |
| if (manifestFile != null) { |
| try { |
| return BundleManifestFactory.createBundleManifest(new InputStreamReader(manifestFile.getContents(true))); |
| } catch (Exception e) { |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Locates the {@link IResource} representing the MANIFEST.MF of a <code>javaProject</code>. |
| * <p> |
| * This implementation searches the source folders of the {@link IJavaProject} and returns the first found |
| * META-INF/MANIFEST.MF as the valid manifest. |
| */ |
| public static IFile locateManifest(IJavaProject javaProject, boolean testBundle) { |
| String manifestLocation = testBundle ? BundleManifestCorePlugin.TEST_MANIFEST_FILE_LOCATION : BundleManifestCorePlugin.MANIFEST_FILE_LOCATION; |
| try { |
| for (IClasspathEntry entry : ServerModuleDelegate.getSourceClasspathEntries(javaProject.getProject(), testBundle)) { |
| IPath path = entry.getPath().append(manifestLocation).removeFirstSegments(1); |
| IFile manifestFileHandle = javaProject.getProject().getFile(path); |
| if (manifestFileHandle.exists()) { |
| return manifestFileHandle; |
| } |
| } |
| |
| if (FacetedProjectFramework.hasProjectFacet(javaProject.getProject(), FacetCorePlugin.WEB_FACET_ID)) { |
| WebArtifactEdit webArtifact = WebArtifactEdit.getWebArtifactEditForRead(javaProject.getProject()); |
| if (webArtifact != null) { |
| IPath webDotXmlPath = webArtifact.getDeploymentDescriptorPath(); |
| if (webDotXmlPath != null) { |
| IPath path = webDotXmlPath.removeLastSegments(2).append(manifestLocation).removeFirstSegments(1); |
| IFile manifestFileHandle = javaProject.getProject().getFile(path); |
| if (manifestFileHandle.exists()) { |
| return manifestFileHandle; |
| } |
| } |
| } |
| } |
| |
| } catch (Exception e) { |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a full qualified location of the META-INF folder. |
| * <p> |
| * This implementation searches the source folders of the {@link IJavaProject} and returns the first found |
| * META-INF/MANIFEST.MF as the valid manifest. |
| */ |
| public static String locateManifestFolder(IJavaProject javaProject) { |
| IResource resource = locateManifest(javaProject, false); |
| if (resource != null) { |
| IContainer container = resource.getParent().getParent(); |
| IPath location = container.getRawLocation(); |
| if (location != null) { |
| return location.toString(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a {@link File} instance for the given <code>javaProject</code>. |
| * <p> |
| * This implementation searches the source folders of the {@link IJavaProject} and returns the first found |
| * META-INF/MANIFEST.MF as the valid manifest. |
| */ |
| public static File locateManifestFile(IJavaProject javaProject, boolean testBundle) { |
| IResource resource = locateManifest(javaProject, testBundle); |
| if (resource != null) { |
| URI uri = convertResourceToUrl(resource); |
| if (uri != null) { |
| return new File(uri); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Converts a given {@link IResource} into a full qualified {@link URI} honoring eventual used Eclipse variables in |
| * the path expression. |
| */ |
| private static URI convertResourceToUrl(IResource resource) { |
| if (resource != null) { |
| URI uri = resource.getRawLocationURI(); |
| if (uri != null) { |
| String scheme = uri.getScheme(); |
| if (FILE_SCHEME.equalsIgnoreCase(scheme)) { |
| return uri; |
| } else if ("sourcecontrol".equals(scheme)) { |
| // special case of Rational Team Concert |
| IPath path = resource.getLocation(); |
| File file = path.toFile(); |
| if (file.exists()) { |
| return file.toURI(); |
| } |
| } else { |
| IPathVariableManager variableManager = ResourcesPlugin.getWorkspace().getPathVariableManager(); |
| return variableManager.resolveURI(uri); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Finds a {@link IResource} identified by a given <code>path</code> in the given <code>project</code> |
| */ |
| private static IResource findResource(IProject project, IPath path) { |
| if (path != null && project != null && path.removeFirstSegments(1) != null) { |
| return project.findMember(path.removeFirstSegments(1)); |
| } |
| return null; |
| } |
| |
| /** |
| * Dumps a new MANIFEST.MF into the given {@link IJavaProject}. |
| */ |
| public static void createNewBundleManifest(IJavaProject javaProject, String symbolicName, String bundleVersion, String providerName, |
| String bundleName, String serverModule, Map<String, String> properties) { |
| |
| BundleManifest manifest = null; |
| |
| File existingManifestFile = locateManifestFile(javaProject, false); |
| if (existingManifestFile != null) { |
| FileReader reader = null; |
| try { |
| reader = new FileReader(existingManifestFile); |
| manifest = BundleManifestFactory.createBundleManifest(new FileReader(existingManifestFile)); |
| } catch (FileNotFoundException e) { |
| } catch (IOException e) { |
| } finally { |
| if (reader != null) { |
| try { |
| reader.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| } else { |
| manifest = BundleManifestFactory.createBundleManifest(); |
| } |
| |
| manifest.setBundleManifestVersion(2); |
| Dictionary<String, String> dictonary = manifest.toDictionary(); |
| if (StringUtils.isNotBlank(symbolicName)) { |
| dictonary.put(Constants.BUNDLE_SYMBOLICNAME, symbolicName); |
| } |
| if (StringUtils.isNotBlank(bundleVersion)) { |
| dictonary.put(Constants.BUNDLE_VERSION, bundleVersion); |
| } |
| if (StringUtils.isNotBlank(bundleName)) { |
| dictonary.put(Constants.BUNDLE_NAME, bundleName); |
| } |
| if (StringUtils.isNotBlank(providerName)) { |
| dictonary.put(Constants.BUNDLE_DESCRIPTION, providerName); |
| } |
| |
| for (Map.Entry<String, String> entry : properties.entrySet()) { |
| if (StringUtils.isNotEmpty(entry.getValue()) && StringUtils.isNotEmpty(entry.getKey())) { |
| dictonary.put(entry.getKey(), entry.getValue()); |
| } |
| } |
| |
| Writer writer = null; |
| try { |
| if (existingManifestFile != null) { |
| writer = new FileWriter(existingManifestFile); |
| } else { |
| writer = new FileWriter(getFirstPossibleManifestFile(javaProject.getProject(), false).getRawLocation().toFile()); |
| } |
| BundleManifest bundleManifest = BundleManifestFactory.createBundleManifest(dictonary); |
| bundleManifest.write(writer); |
| } catch (IOException e) { |
| } finally { |
| if (writer != null) { |
| try { |
| writer.flush(); |
| writer.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| } |
| |
| public static void createNewParManifest(IProject project, String symbolicName, String version, String name, String description) { |
| Dictionary<String, String> manifest = BundleManifestFactory.createBundleManifest().toDictionary(); |
| if (StringUtils.isNotBlank(symbolicName)) { |
| manifest.put("Application-SymbolicName", symbolicName); |
| } |
| if (StringUtils.isNotBlank(version)) { |
| manifest.put("Application-Version", version); |
| } |
| if (StringUtils.isNotBlank(name)) { |
| manifest.put("Application-Name", name); |
| } |
| if (StringUtils.isNotBlank(description)) { |
| manifest.put("Application-Description", description); |
| } |
| |
| Writer writer = null; |
| try { |
| writer = new FileWriter(getFirstPossibleManifestFile(project, false).getRawLocation().toFile()); |
| BundleManifest bundleManifest = BundleManifestFactory.createBundleManifest(manifest); |
| bundleManifest.write(writer); |
| } catch (IOException e) { |
| } finally { |
| if (writer != null) { |
| try { |
| writer.flush(); |
| writer.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| } |
| |
| public static IFile getFirstPossibleManifestFile(final IProject project, boolean isTestManifest) { |
| try { |
| if (FacetUtils.hasNature(project, JavaCore.NATURE_ID)) { |
| |
| List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>( |
| ServerModuleDelegate.getSourceClasspathEntries(project, isTestManifest)); |
| Collections.sort(entries, new Comparator<IClasspathEntry>() { |
| |
| public int compare(IClasspathEntry o1, IClasspathEntry o2) { |
| String s1 = o1.getPath().toString(); |
| String s2 = o2.getPath().toString(); |
| if (("/" + project.getName() + "/src/main/resources").equals(s1)) { |
| return -1; |
| } else if (("/" + project.getName() + "/src/test/resources").equals(s1)) { |
| return -1; |
| } |
| if (("/" + project.getName() + "/src/main/resources").equals(s2)) { |
| return 1; |
| } else if (("/" + project.getName() + "/src/test/resources").equals(s2)) { |
| return 1; |
| } |
| return s1.compareTo(s2); |
| } |
| }); |
| |
| for (IClasspathEntry entry : entries) { |
| return createNewManifestInFolder(findResource(project, entry.getPath()), isTestManifest); |
| } |
| } else { |
| return createNewManifestInFolder(project, isTestManifest); |
| } |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| return null; |
| } |
| |
| private static IFile createNewManifestInFolder(IResource resource, boolean isTestManifest) throws CoreException { |
| String manifestFilePath = "META-INF/" |
| + (isTestManifest ? BundleManifestCorePlugin.TEST_MANIFEST_FILE_NAME : BundleManifestCorePlugin.MANIFEST_FILE_NAME); |
| IFile manifestFile = null; |
| if (resource instanceof IFolder) { |
| manifestFile = ((IFolder) resource).getFile(manifestFilePath); |
| } else if (resource instanceof IProject) { |
| manifestFile = ((IProject) resource).getFile(manifestFilePath); |
| } |
| if (manifestFile != null && !manifestFile.exists()) { |
| if (!manifestFile.getParent().exists()) { |
| ((IFolder) manifestFile.getParent()).create(true, true, new NullProgressMonitor()); |
| } |
| manifestFile.create(new ByteArrayInputStream("Manifest-Version: 1.0".getBytes()), true, new NullProgressMonitor()); |
| } |
| return manifestFile; |
| } |
| |
| public static int getLineNumber(IDocument document, BundleManifestHeader header, String valueSubstring) { |
| // make sure that we have a line number in case the bundle model is crashed |
| if (header == null) { |
| return 0; |
| } |
| |
| for (int l = header.getLineNumber(); l < header.getLineNumber() + header.getLinesSpan(); l++) { |
| try { |
| IRegion lineRegion = document.getLineInformation(l); |
| String lineStr = document.get(lineRegion.getOffset(), lineRegion.getLength()); |
| if (lineStr.indexOf(valueSubstring) >= 0) { |
| return l + 1; |
| } |
| } catch (BadLocationException ble) { |
| } |
| } |
| // it might span multiple lines, try a longer algorithm |
| try { |
| IRegion lineRegion = document.getLineInformation(header.getLineNumber()); |
| String lineStr = document.get(lineRegion.getOffset(), lineRegion.getLength()); |
| for (int l = header.getLineNumber() + 1; l < header.getLineNumber() + header.getLinesSpan(); l++) { |
| lineRegion = document.getLineInformation(l); |
| lineStr += document.get(lineRegion.getOffset() + 1/* the space */, lineRegion.getLength()); |
| if (lineStr.indexOf(valueSubstring) >= 0) { |
| return l; |
| } |
| } |
| } catch (BadLocationException ble) { |
| } |
| return header.getLineNumber() + 1; |
| } |
| |
| public static int getPackageLineNumber(IDocument document, BundleManifestHeader header, ManifestElement element) { |
| String packageName = element.getValue(); |
| if (element.getDirectiveKeys() != null || element.getKeys() != null) { |
| return getLineNumber(document, header, packageName + ";"); |
| } |
| |
| // check for this exact package on the last line |
| try { |
| IRegion lineRegion = document.getLineInformation(header.getLineNumber() + header.getLinesSpan() - 1); |
| String lineStr = document.get(lineRegion.getOffset(), lineRegion.getLength()); |
| if (lineStr.endsWith(packageName)) { |
| return header.getLineNumber() + header.getLinesSpan(); |
| } |
| } catch (BadLocationException ble) { |
| } |
| |
| // search all except last line |
| return getLineNumber(document, header, packageName + ","); |
| } |
| |
| } |
