| package org.eclipse.scout.sdk.compatibility.v37v41.internal; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.URIUtil; |
| import org.eclipse.pde.internal.core.target.ExternalFileTargetHandle; |
| import org.eclipse.pde.internal.core.target.IUBundleContainer; |
| import org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper; |
| import org.eclipse.pde.internal.core.target.WorkspaceFileTargetHandle; |
| import org.eclipse.pde.internal.core.target.provisional.IBundleContainer; |
| import org.eclipse.pde.internal.core.target.provisional.ITargetDefinition; |
| import org.eclipse.pde.internal.core.target.provisional.ITargetHandle; |
| import org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService; |
| import org.eclipse.pde.internal.core.target.provisional.NameVersionDescriptor; |
| import org.eclipse.scout.sdk.compatibility.P2Utility; |
| import org.eclipse.scout.sdk.compatibility.internal.FeatureDefinition; |
| import org.eclipse.scout.sdk.compatibility.PlatformVersionUtility; |
| import org.eclipse.scout.sdk.compatibility.internal.ScoutCompatibilityActivator; |
| import org.eclipse.scout.sdk.compatibility.internal.service.ITargetPlatformCompatService; |
| import org.eclipse.scout.sdk.compatibility.v37v41.internal.provisional.LoadTargetDefinitionJobSync; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| @SuppressWarnings("restriction") |
| public class TargetPlatformCompatService implements ITargetPlatformCompatService { |
| |
| private interface ITargetFileModification { |
| void contribute(List<IBundleContainer> liveList, Map<IUBundleContainer, Set<FeatureDefinition>> features, ITargetPlatformService svc) throws CoreException; |
| } |
| |
| @Override |
| public IStatus resolveTargetPlatform(IFile targetFile, boolean loadPlatform, IProgressMonitor monitor) throws CoreException { |
| ITargetPlatformService targetService = ScoutCompatibilityActivator.getDefault().acquireService(ITargetPlatformService.class); |
| ITargetHandle handle = targetService.getTarget(targetFile); |
| ITargetDefinition def = handle.getTargetDefinition(); |
| return resolveTarget(def, loadPlatform, monitor); |
| } |
| |
| @Override |
| public URI getCurrentTargetFile() throws CoreException { |
| ITargetPlatformService targetService = ScoutCompatibilityActivator.getDefault().acquireService(ITargetPlatformService.class); |
| ITargetHandle workspaceTargetHandle = targetService.getWorkspaceTargetHandle(); |
| if (workspaceTargetHandle instanceof WorkspaceFileTargetHandle && workspaceTargetHandle.exists()) { |
| IFile f = ((WorkspaceFileTargetHandle) workspaceTargetHandle).getTargetFile(); |
| if (f != null && f.exists()) { |
| return f.getLocationURI(); |
| } |
| } |
| else if (workspaceTargetHandle instanceof ExternalFileTargetHandle && workspaceTargetHandle.exists()) { |
| return ((ExternalFileTargetHandle) workspaceTargetHandle).getLocation(); |
| } |
| return null; |
| } |
| |
| @Override |
| public IStatus resolveTargetPlatform(Set<File> absolutePaths, String targetName, boolean loadPlatform, IProgressMonitor monitor) throws CoreException { |
| ITargetPlatformService tpService = ScoutCompatibilityActivator.getDefault().acquireService(ITargetPlatformService.class); |
| ITargetDefinition targetDef = tpService.newTarget(); |
| targetDef.setName(targetName); |
| |
| List<IBundleContainer> bundleContainers = new ArrayList<IBundleContainer>(); |
| for (File dir : absolutePaths) { |
| bundleContainers.add(tpService.newDirectoryContainer(dir.getAbsolutePath())); |
| } |
| targetDef.setBundleContainers(bundleContainers.toArray(new IBundleContainer[bundleContainers.size()])); |
| targetDef.setArch(Platform.getOSArch()); |
| targetDef.setOS(Platform.getOS()); |
| targetDef.setWS(Platform.getWS()); |
| targetDef.setNL(Platform.getNL()); |
| tpService.saveTargetDefinition(targetDef); |
| |
| return resolveTarget(targetDef, loadPlatform, monitor); |
| } |
| |
| private IStatus resolveTarget(ITargetDefinition def, boolean loadPlatform, IProgressMonitor monitor) { |
| IStatus result = def.resolve(monitor); |
| if (loadPlatform && result.isOK()) { |
| LoadTargetDefinitionJobSync loadJob = new LoadTargetDefinitionJobSync(def); |
| result = loadJob.run(monitor); |
| } |
| return result; |
| } |
| |
| @Override |
| public void removeInstallableUnitsFromTarget(IFile targetFile, final String[] unitIds) throws CoreException { |
| modifyTargetFile(targetFile, new ITargetFileModification() { |
| @Override |
| public void contribute(List<IBundleContainer> liveList, Map<IUBundleContainer, Set<FeatureDefinition>> features, ITargetPlatformService svc) throws CoreException { |
| for (Set<FeatureDefinition> featureOfContainer : features.values()) { |
| Iterator<FeatureDefinition> it = featureOfContainer.iterator(); |
| while (it.hasNext()) { |
| FeatureDefinition def = it.next(); |
| for (String featureToRemove : unitIds) { |
| if (featureToRemove != null && featureToRemove.equals(def.id)) { |
| it.remove(); |
| } |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void addDirectoryLocationToTarget(IFile targetFile, final String[] dirs) throws CoreException { |
| modifyTargetFile(targetFile, new ITargetFileModification() { |
| @Override |
| public void contribute(List<IBundleContainer> liveList, Map<IUBundleContainer, Set<FeatureDefinition>> features, ITargetPlatformService svc) { |
| for (String dir : dirs) { |
| if (dir != null && dir.trim().length() > 0) { |
| liveList.add(svc.newDirectoryContainer(dir)); |
| } |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void addInstallableUnitToTarget(IFile targetFile, final String unitId, final String version, final String repository, final IProgressMonitor monitor) throws CoreException { |
| modifyTargetFile(targetFile, new ITargetFileModification() { |
| @Override |
| public void contribute(List<IBundleContainer> liveList, Map<IUBundleContainer, Set<FeatureDefinition>> features, ITargetPlatformService svc) throws CoreException { |
| try { |
| String ver = version; |
| if (ver == null || ver.trim().length() < 1) { |
| ver = P2Utility.getLatestVersion(unitId, URIUtil.fromString(repository), monitor); |
| } |
| |
| IUBundleContainer container = getContainer(repository, features.keySet()); |
| FeatureDefinition fd = new FeatureDefinition(); |
| fd.id = unitId; |
| fd.version = ver; |
| if (container == null) { |
| URI uri = URIUtil.fromString(repository); |
| IUBundleContainer newIULocation = (IUBundleContainer) svc.newIUContainer(new String[]{unitId}, new String[]{ver}, new URI[]{uri}, 0); |
| Set<FeatureDefinition> set = new HashSet<FeatureDefinition>(1); |
| set.add(fd); |
| features.put(newIULocation, set); |
| } |
| else { |
| features.get(container).add(fd); |
| } |
| } |
| catch (URISyntaxException e) { |
| throw new CoreException(new Status(IStatus.ERROR, ScoutCompatibilityActivator.PLUGIN_ID, "Unable to parse url '" + repository + "'.", e)); |
| } |
| } |
| }); |
| } |
| |
| // |
| // @Override |
| // public void addInstallableUnitsToTarget(IFile targetFile, String[] unitIds, String[] versions, String[] repositories) throws CoreException { |
| // URI[] uris = new URI[repositories.length]; |
| // try { |
| // for (int i = 0; i < repositories.length; i++) { |
| // uris[i] = new URI(repositories[i]); |
| // } |
| // } |
| // catch (URISyntaxException e) { |
| // throw new CoreException(new Status(IStatus.ERROR, ScoutCompatibilityActivator.PLUGIN_ID, "invalid URI provided", e)); |
| // } |
| // |
| // ITargetPlatformService svc = ScoutCompatibilityActivator.getDefault().acquireService(ITargetPlatformService.class); |
| // ITargetHandle handle = svc.getTarget(targetFile); |
| // ITargetDefinition td = handle.getTargetDefinition(); |
| // IBundleContainer[] features = td.getBundleContainers(); |
| // |
| // int s = unitIds.length; |
| // if (features != null) { |
| // s += features.length; |
| // } |
| // ArrayList<IBundleContainer> newList = new ArrayList<IBundleContainer>(s); |
| // if (features != null && features.length > 0) { |
| // for (IBundleContainer container : features) { |
| // newList.add(container); |
| // } |
| // } |
| // for (int i = 0; i < unitIds.length; i++) { |
| // IUBundleContainer group = (IUBundleContainer) svc.newIUContainer(new String[]{unitIds[i]}, new String[]{versions[i]}, new URI[]{uris[i]}, |
| // IUBundleContainer.INCLUDE_SOURCE); |
| // newList.add(group); |
| // } |
| // td.setBundleContainers(newList.toArray(new IBundleContainer[newList.size()])); |
| // svc.saveTargetDefinition(td); |
| // } |
| |
| /** |
| * workaround for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=432494 |
| */ |
| private Set<FeatureDefinition> getValueOf(Map<IUBundleContainer, Set<FeatureDefinition>> map, IUBundleContainer objectToFind) { |
| for (Entry<IUBundleContainer, Set<FeatureDefinition>> entry : map.entrySet()) { |
| if (objectToFind != null && objectToFind.equals(entry.getKey())) { |
| return entry.getValue(); |
| } |
| } |
| return null; |
| } |
| |
| private boolean isRepository(Element location, IUBundleContainer iubc) throws URISyntaxException { |
| final String REPOSITORY = "repository"; // from org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper.REPOSITORY |
| final String ATTR_LOCATION = "location"; |
| NodeList repositories = location.getElementsByTagName(REPOSITORY); |
| for (int i = 0; i < repositories.getLength(); i++) { |
| Element candidate = (Element) repositories.item(i); |
| if (candidate.hasAttribute(ATTR_LOCATION)) { |
| String loc = candidate.getAttribute(ATTR_LOCATION); |
| URI uri = URIUtil.fromString(loc); |
| for (URI repoUri : iubc.getRepositories()) { |
| if (URIUtil.sameURI(uri, repoUri)) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private List<NameVersionDescriptor> getFeatures(IUBundleContainer iubc, Document document) throws URISyntaxException { |
| final String LOCATION = "location"; // from org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper.LOCATION |
| final String INSTALLABLE_UNIT = "unit"; // from org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper.INSTALLABLE_UNIT |
| final String ATTR_ID = "id"; // from org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper.ATTR_ID |
| final String ATTR_VERSION = "version"; // from org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper.ATTR_VERSION |
| |
| NodeList locations = document.getDocumentElement().getElementsByTagName(LOCATION); |
| ArrayList<NameVersionDescriptor> result = new ArrayList<NameVersionDescriptor>(locations.getLength()); |
| for (int i = 0; i < locations.getLength(); i++) { |
| Element location = (Element) locations.item(i); |
| if (isRepository(location, iubc)) { |
| NodeList childNodes = location.getChildNodes(); |
| for (int j = 0; j < childNodes.getLength(); j++) { |
| Node nn = childNodes.item(j); |
| if (nn.getNodeType() == Node.ELEMENT_NODE && INSTALLABLE_UNIT.equals(nn.getNodeName())) { |
| Element e = (Element) nn; |
| if (e.hasAttribute(ATTR_ID)) { |
| String id = e.getAttribute(ATTR_ID); |
| String version = e.getAttribute(ATTR_VERSION); |
| result.add(new NameVersionDescriptor(id, version)); |
| } |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| private static IUBundleContainer getContainer(String uri, Set<IUBundleContainer> containers) throws URISyntaxException { |
| URI searchUri = URIUtil.fromString(uri); |
| for (IUBundleContainer container : containers) { |
| for (URI repo : container.getRepositories()) { |
| if (URIUtil.sameURI(searchUri, repo)) { |
| return container; |
| } |
| } |
| } |
| return null; |
| } |
| |
| private void modifyTargetFile(IFile targetFile, ITargetFileModification modification) throws CoreException { |
| final String encoding = "UTF-8"; |
| ITargetPlatformService svc = ScoutCompatibilityActivator.getDefault().acquireService(ITargetPlatformService.class); |
| ITargetHandle handle = svc.getTarget(targetFile); |
| ITargetDefinition td = handle.getTargetDefinition(); |
| IBundleContainer[] features = td.getBundleContainers(); |
| int size = 1; |
| if (features != null) { |
| size += features.length; |
| } |
| |
| try { |
| ByteArrayOutputStream out = new ByteArrayOutputStream(); |
| TargetDefinitionPersistenceHelper.persistXML(td, out); |
| String xml = out.toString(encoding); |
| DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); |
| Document document = docBuilder.parse(new ByteArrayInputStream(xml.getBytes(encoding))); |
| |
| Map<IUBundleContainer, Set<FeatureDefinition>> p2FeatureMap = new HashMap<IUBundleContainer, Set<FeatureDefinition>>(size); |
| List<IBundleContainer> locations = new ArrayList<IBundleContainer>(size); |
| if (features != null) { |
| for (IBundleContainer container : features) { |
| if (container instanceof IUBundleContainer) { |
| IUBundleContainer iubc = (IUBundleContainer) container; |
| List<NameVersionDescriptor> fs = getFeatures(iubc, document); |
| |
| Set<FeatureDefinition> featureSet = getValueOf(p2FeatureMap, iubc); |
| if (featureSet == null) { |
| featureSet = new HashSet<FeatureDefinition>(fs.size()); |
| p2FeatureMap.put(iubc, featureSet); |
| } |
| |
| for (NameVersionDescriptor f : fs) { |
| FeatureDefinition fd = new FeatureDefinition(); |
| fd.id = f.getId(); |
| fd.version = f.getVersion(); |
| featureSet.add(fd); |
| } |
| } |
| else { |
| locations.add(container); |
| } |
| } |
| } |
| |
| modification.contribute(locations, p2FeatureMap, svc); |
| |
| for (Entry<IUBundleContainer, Set<FeatureDefinition>> entry : p2FeatureMap.entrySet()) { |
| if (!entry.getValue().isEmpty()) { |
| String[] unitIds = new String[entry.getValue().size()]; |
| String[] versions = new String[entry.getValue().size()]; |
| int i = 0; |
| for (FeatureDefinition f : entry.getValue()) { |
| unitIds[i] = f.id; |
| if (f.version == null) { |
| versions[i] = PlatformVersionUtility.EMPTY_VERSION_STR; |
| } |
| else { |
| versions[i] = f.version; |
| } |
| i++; |
| } |
| |
| locations.add(svc.newIUContainer(unitIds, versions, entry.getKey().getRepositories(), IUBundleContainer.INCLUDE_SOURCE)); |
| } |
| } |
| |
| td.setBundleContainers(locations.toArray(new IBundleContainer[locations.size()])); |
| svc.saveTargetDefinition(td); |
| } |
| catch (Exception e) { |
| throw new CoreException(new Status(IStatus.ERROR, ScoutCompatibilityActivator.PLUGIN_ID, "Unable to parse installable units.", e)); |
| } |
| } |
| } |
