| /******************************************************************************* |
| * Copyright (c) 2008, 2017 IBM Corporation and others. |
| * |
| * This |
| * program and the accompanying materials are made available under the terms of |
| * the Eclipse Public License 2.0 which accompanies this distribution, and is |
| t https://www.eclipse.org/legal/epl-2.0/ |
| t |
| t SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: IBM Corporation - initial API and implementation |
| ******************************************************************************/ |
| |
| package org.eclipse.pde.internal.build.publisher; |
| |
| import java.io.File; |
| import java.util.*; |
| import java.util.jar.JarFile; |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.types.FileSet; |
| import org.apache.tools.ant.types.PatternSet.NameEntry; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.equinox.p2.publisher.PublisherInfo; |
| import org.eclipse.pde.build.Constants; |
| import org.eclipse.pde.internal.build.IBuildPropertiesConstants; |
| import org.eclipse.pde.internal.build.Utils; |
| import org.eclipse.pde.internal.build.builder.ModelBuildScriptGenerator; |
| import org.eclipse.pde.internal.build.builder.ModelBuildScriptGenerator.CompiledEntry; |
| |
| public class GatherBundleTask extends AbstractPublisherTask { |
| static final private String API_DESCRIPTION = ".api_description"; //$NON-NLS-1$ |
| |
| static public class OutputFileSet extends FileSet { |
| private String library; |
| |
| public OutputFileSet() { |
| super(); |
| } |
| |
| public String getLibrary() { |
| return this.library; |
| } |
| |
| public void setLibrary(String value) { |
| this.library = value; |
| } |
| |
| @Override |
| public synchronized void setIncludes(String includes) { |
| super.setIncludes(includes); |
| } |
| } |
| |
| private String buildResultFolder = null; |
| private String targetFolder = null; |
| private String gatheredSource = null; |
| private String unpack = null; |
| private final Map<String, Set<OutputFileSet>> sourceMap = new HashMap<>(); |
| |
| @Override |
| public void execute() throws BuildException { |
| GatheringComputer computer = createComputer(); |
| |
| GatherBundleAction action = null; |
| if (targetFolder != null) { |
| File targetFile = new File(targetFolder); |
| action = new GatherBundleAction(targetFile, targetFile); |
| } else |
| action = new GatherBundleAction(new File(baseDirectory), new File(buildResultFolder)); |
| action.setComputer(computer); |
| action.setUnpack(unpack); |
| |
| PublisherInfo info = getPublisherInfo(); |
| BuildPublisherApplication application = createPublisherApplication(); |
| application.addAction(action); |
| try { |
| application.run(info); |
| } catch (Exception e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| |
| protected GatheringComputer createComputer() { |
| Properties properties = getBuildProperties(); |
| GatheringComputer computer = new GatheringComputer(); |
| |
| if (targetFolder != null) { |
| FileSet fileSet = new FileSet(); |
| fileSet.setProject(getProject()); |
| fileSet.setDir(new File(targetFolder)); |
| NameEntry includes = fileSet.createInclude(); |
| includes.setName("**"); //$NON-NLS-1$ |
| NameEntry excludes = fileSet.createExclude(); |
| excludes.setName(JarFile.MANIFEST_NAME); |
| |
| if (new File(targetFolder, JarFile.MANIFEST_NAME).exists()) |
| computer.addFile(targetFolder, JarFile.MANIFEST_NAME); |
| computer.addFiles(targetFolder, fileSet.getDirectoryScanner().getIncludedFiles()); |
| return computer; |
| } |
| |
| CompiledEntry[] entries = null; |
| try { |
| entries = ModelBuildScriptGenerator.extractEntriesToCompile(properties, null); |
| } catch (CoreException e) { |
| //nothing being compiled? |
| } |
| |
| int numIncludes = 0; |
| String include = (String) properties.get(IBuildPropertiesConstants.PROPERTY_BIN_INCLUDES); |
| String[] splitIncludes = Utils.getArrayFromString(include); |
| String exclude = (String) properties.get(IBuildPropertiesConstants.PROPERTY_BIN_EXCLUDES); |
| |
| FileSet fileSet = new FileSet(); |
| fileSet.setProject(getProject()); |
| fileSet.setDir(new File(baseDirectory)); |
| |
| for (int i = 0; i < splitIncludes.length; i++) { |
| String entry = splitIncludes[i]; |
| if (entry.equals(ModelBuildScriptGenerator.DOT)) |
| continue; |
| |
| NameEntry fileInclude = fileSet.createInclude(); |
| fileInclude.setName(entry); |
| ++numIncludes; |
| } |
| |
| if (numIncludes > 0) { |
| //we want to exclude the manifest and compiled libraries from this set, they are added separately |
| String extraExcludes = JarFile.MANIFEST_NAME; |
| for (int i = 0; entries != null && i < entries.length; i++) { |
| String name = entries[i].getName(false); |
| if (!name.equals(ModelBuildScriptGenerator.DOT)) { |
| String formatedName = name + (entries[i].getType() == CompiledEntry.FOLDER ? "/" : ""); //$NON-NLS-1$//$NON-NLS-2$ |
| extraExcludes += "," + formatedName; //$NON-NLS-1$ |
| } |
| } |
| |
| String[] splitExcludes = Utils.getArrayFromString(exclude != null ? exclude + "," + extraExcludes : extraExcludes); //$NON-NLS-1$ |
| for (int i = 0; i < splitExcludes.length; i++) { |
| NameEntry fileExclude = fileSet.createExclude(); |
| fileExclude.setName(splitExcludes[i]); |
| } |
| |
| List<String> includedFiles = Arrays.asList(fileSet.getDirectoryScanner().getIncludedFiles()); |
| LinkedHashSet<String> set = new LinkedHashSet<>(includedFiles); |
| |
| // Manifest must go first, and must have been specifically excluded earlier from the buildResultFolder to not get added. |
| if (new File(buildResultFolder, JarFile.MANIFEST_NAME).exists()) |
| computer.addFile(buildResultFolder, JarFile.MANIFEST_NAME); |
| |
| // The plugin.xml and fragment.xml may have had versions changed, take them from the buildResultFolder |
| if (set.contains(Constants.PLUGIN_FILENAME_DESCRIPTOR) && new File(buildResultFolder, Constants.PLUGIN_FILENAME_DESCRIPTOR).exists()) { |
| set.remove(Constants.PLUGIN_FILENAME_DESCRIPTOR); |
| computer.addFile(buildResultFolder, Constants.PLUGIN_FILENAME_DESCRIPTOR); |
| } |
| if (set.contains(Constants.FRAGMENT_FILENAME_DESCRIPTOR) && new File(buildResultFolder, Constants.FRAGMENT_FILENAME_DESCRIPTOR).exists()) { |
| set.remove(Constants.FRAGMENT_FILENAME_DESCRIPTOR); |
| computer.addFile(buildResultFolder, Constants.FRAGMENT_FILENAME_DESCRIPTOR); |
| } |
| |
| if (new File(buildResultFolder, API_DESCRIPTION).exists()) |
| computer.addFile(buildResultFolder, API_DESCRIPTION); |
| |
| //everything else |
| computer.addFiles(baseDirectory, set.toArray(new String[set.size()])); |
| } |
| |
| boolean dotIncluded = false; |
| if (entries != null) { |
| //add all the compiled libraries |
| boolean haveEntries = false; |
| fileSet = new FileSet(); |
| fileSet.setProject(getProject()); |
| fileSet.setDir(new File(buildResultFolder)); |
| for (int i = 0; i < entries.length; i++) { |
| String name = entries[i].getName(false); |
| if (name.equals(ModelBuildScriptGenerator.DOT)) { |
| dotIncluded = true; |
| continue; |
| } |
| |
| if (sourceMap.containsKey(name) && entries[i].getType() == CompiledEntry.FOLDER) { |
| Set<OutputFileSet> folders = sourceMap.get(name); |
| processOutputFolders(folders, name, computer); |
| } else { |
| NameEntry fileInclude = fileSet.createInclude(); |
| fileInclude.setName(name + ((entries[i].getType() == CompiledEntry.FOLDER) ? "/" : "")); //$NON-NLS-1$ //$NON-NLS-2$ |
| haveEntries = true; |
| } |
| } |
| if (haveEntries) { |
| computer.addFiles(buildResultFolder, fileSet.getDirectoryScanner().getIncludedFiles()); |
| } |
| } |
| |
| if (dotIncluded) { |
| //special handling for '.' |
| if (sourceMap.containsKey(ModelBuildScriptGenerator.DOT)) { |
| Set<OutputFileSet> folders = sourceMap.get(ModelBuildScriptGenerator.DOT); |
| processOutputFolders(folders, ModelBuildScriptGenerator.DOT, computer); |
| } else { |
| fileSet = new FileSet(); |
| fileSet.setProject(getProject()); |
| fileSet.setDir(new File(buildResultFolder, ModelBuildScriptGenerator.EXPANDED_DOT)); |
| NameEntry fileInclude = fileSet.createInclude(); |
| fileInclude.setName("**"); //$NON-NLS-1$ |
| if (exclude != null) { |
| String[] splitExcludes = Utils.getArrayFromString(exclude); |
| for (int i = 0; i < splitExcludes.length; i++) { |
| NameEntry fileExclude = fileSet.createExclude(); |
| fileExclude.setName(splitExcludes[i]); |
| } |
| } |
| |
| computer.addFiles(buildResultFolder + '/' + ModelBuildScriptGenerator.EXPANDED_DOT, fileSet.getDirectoryScanner().getIncludedFiles()); |
| } |
| } |
| |
| if (gatheredSource != null) { |
| File sourceFile = new File(gatheredSource); |
| if (sourceFile.exists()) { |
| fileSet = new FileSet(); |
| fileSet.setProject(getProject()); |
| fileSet.setDir(sourceFile); |
| NameEntry fileInclude = fileSet.createInclude(); |
| fileInclude.setName("**"); //$NON-NLS-1$ |
| computer.addFiles(gatheredSource, fileSet.getDirectoryScanner().getIncludedFiles()); |
| } |
| } |
| |
| return computer; |
| } |
| |
| private void processOutputFolders(Set<OutputFileSet> folders, String key, GatheringComputer computer) { |
| boolean dot = key.equals(ModelBuildScriptGenerator.DOT); |
| for (Iterator<OutputFileSet> iterator = folders.iterator(); iterator.hasNext();) { |
| OutputFileSet outputFiles = iterator.next(); |
| File baseDir = outputFiles.getDir(); |
| String[] includes = outputFiles.mergeIncludes(getProject()); |
| //handling more than one include here would involve correlating the includes files |
| //with the pattern that included them. |
| if (includes.length == 1) { |
| IPath prefix = new Path(includes[0]).removeLastSegments(1); |
| int count = prefix.segmentCount(); |
| String[] files = outputFiles.getDirectoryScanner().getIncludedFiles(); |
| for (int i = 0; i < files.length; i++) { |
| IPath suffix = new Path(files[i]).removeFirstSegments(count); |
| String computerPath = dot ? suffix.toString() : key + '/' + suffix.toString(); |
| computer.addFile(computerPath, new File(baseDir, files[i])); |
| } |
| } |
| } |
| } |
| |
| public void setBuildResultFolder(String buildResultFolder) { |
| this.buildResultFolder = buildResultFolder; |
| } |
| |
| public void setUnpack(String unpack) { |
| if (unpack != null && unpack.length() > 0 && !unpack.startsWith(ANT_PREFIX)) |
| this.unpack = unpack; |
| } |
| |
| public void setGatheredSource(String gatheredSource) { |
| if (gatheredSource != null && gatheredSource.length() > 0 && !gatheredSource.startsWith(ANT_PREFIX)) |
| this.gatheredSource = gatheredSource; |
| } |
| |
| public void setTargetFolder(String targetFolder) { |
| if (targetFolder != null && targetFolder.length() > 0 && !targetFolder.startsWith(ANT_PREFIX)) |
| this.targetFolder = targetFolder; |
| } |
| |
| public void addConfiguredOutputFolder(OutputFileSet output) { |
| String key = output.getLibrary(); |
| if (sourceMap.containsKey(key)) { |
| Set<OutputFileSet> set = sourceMap.get(key); |
| set.add(output); |
| } else { |
| Set<OutputFileSet> set = new HashSet<>(); |
| set.add(output); |
| sourceMap.put(key, set); |
| } |
| } |
| } |