| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| package org.apache.easyant.core.services; |
| |
| import org.apache.easyant.core.EasyAntConstants; |
| import org.apache.easyant.core.EasyAntMagicNames; |
| import org.apache.easyant.core.ant.ProjectUtils; |
| import org.apache.easyant.core.ant.listerners.TaskCollectorFromImplicitTargetListener; |
| import org.apache.easyant.core.descriptor.EasyAntModuleDescriptor; |
| import org.apache.easyant.core.descriptor.PluginType; |
| import org.apache.easyant.core.descriptor.PropertyDescriptor; |
| import org.apache.easyant.core.parser.DefaultEasyAntXmlModuleDescriptorParser; |
| import org.apache.easyant.core.parser.EasyAntModuleDescriptorParser; |
| import org.apache.easyant.core.report.*; |
| import org.apache.easyant.tasks.*; |
| import org.apache.ivy.Ivy; |
| import org.apache.ivy.ant.IvyAntSettings; |
| import org.apache.ivy.core.IvyContext; |
| import org.apache.ivy.core.module.id.ModuleId; |
| import org.apache.ivy.core.module.id.ModuleRevisionId; |
| import org.apache.ivy.core.report.ArtifactDownloadReport; |
| import org.apache.ivy.core.report.ResolveReport; |
| import org.apache.ivy.core.resolve.IvyNode; |
| import org.apache.ivy.core.resolve.ResolveOptions; |
| import org.apache.ivy.core.resolve.ResolvedModuleRevision; |
| import org.apache.ivy.core.settings.IvySettings; |
| import org.apache.ivy.plugins.matcher.PatternMatcher; |
| import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry; |
| import org.apache.ivy.plugins.repository.url.URLResource; |
| import org.apache.ivy.plugins.resolver.DependencyResolver; |
| import org.apache.ivy.util.Message; |
| import org.apache.tools.ant.*; |
| import org.apache.tools.ant.property.ParseNextProperty; |
| import org.apache.tools.ant.property.PropertyExpander; |
| import org.apache.tools.ant.taskdefs.Property; |
| import org.apache.tools.ant.types.FileSet; |
| import org.apache.tools.ant.types.Path; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.text.ParsePosition; |
| import java.util.Enumeration; |
| import java.util.Map; |
| import java.util.Properties; |
| |
| public class DefaultPluginService implements PluginService { |
| |
| private final EasyAntModuleDescriptorParser parser; |
| |
| private final Ivy ivyInstance; |
| private final IvyAntSettings easyantIvySettings; |
| |
| private boolean offlineMode; |
| |
| /** |
| * This is the default constructor, the IvyContext should be the IvyContext configured to the easyant ivy instance |
| * |
| * @param easyantIvySettings the easyant ivy instance |
| */ |
| public DefaultPluginService(final IvyAntSettings easyantIvySettings) { |
| this(easyantIvySettings, new DefaultEasyAntXmlModuleDescriptorParser()); |
| } |
| |
| /** |
| * A custom constructor if you want to specify your own parser / configuration service, you should use this |
| * constructor the IvyContext should be the IvyContext configured to the easyant ivy instance |
| * |
| * @param easyantIvySetings the easyant ivy instance |
| * @param parser a valid easyantModuleDescriptor |
| */ |
| public DefaultPluginService(final IvyAntSettings easyantIvySetings, EasyAntModuleDescriptorParser parser) { |
| this.easyantIvySettings = easyantIvySetings; |
| this.ivyInstance = easyantIvySetings.getConfiguredIvyInstance(easyantIvySetings); |
| if (parser == null) { |
| throw new IllegalArgumentException("You must set a valid easyant module descriptor parser"); |
| } |
| this.parser = parser; |
| ModuleDescriptorParserRegistry.getInstance().addParser(parser); |
| } |
| |
| public EasyAntReport getPluginInfo(File pluginIvyFile, File sourceDirectory, String conf) throws Exception { |
| IvyContext.pushNewContext().setIvy(ivyInstance); |
| EasyAntReport eaReport = null; |
| try { |
| |
| ResolveOptions resolveOptions = buildResolveOptions(conf); |
| ResolveReport report = IvyContext.getContext().getIvy().getResolveEngine() |
| .resolve(pluginIvyFile.toURI().toURL(), resolveOptions); |
| eaReport = new EasyAntReport(); |
| eaReport.setResolveReport(report); |
| eaReport.setModuleDescriptor(report.getModuleDescriptor()); |
| |
| Project project = buildProject(); |
| |
| // expose resolve report for import deferred |
| project.addReference(EasyAntMagicNames.IMPORTED_MODULES_RESOLVE_REPORT_REF, report); |
| |
| // emulate top level project |
| ImportTestModule importTestModule = new ImportTestModule(); |
| importTestModule.setModuleIvy(pluginIvyFile); |
| importTestModule.setSourceDirectory(sourceDirectory); |
| importTestModule.setOwningTarget(ProjectUtils.createTopLevelTarget()); |
| importTestModule.setLocation(new Location(ProjectUtils.emulateMainScript(project).getAbsolutePath())); |
| importTestModule.setProject(project); |
| importTestModule.execute(); |
| |
| analyseProject(project, eaReport, conf); |
| } catch (Exception e) { |
| throw new Exception("An error occured while fetching plugin informations : " + e.getMessage(), e); |
| } finally { |
| IvyContext.popContext(); |
| } |
| return eaReport; |
| |
| } |
| |
| private ResolveOptions buildResolveOptions(String conf) { |
| ResolveOptions resolveOptions = new ResolveOptions(); |
| resolveOptions.setLog(ResolveOptions.LOG_QUIET); |
| resolveOptions.setConfs(conf.split(",")); |
| resolveOptions.setUseCacheOnly(offlineMode); |
| return resolveOptions; |
| } |
| |
| public EasyAntReport getPluginInfo(final ModuleRevisionId moduleRevisionId, String conf) throws Exception { |
| IvyContext.pushNewContext().setIvy(ivyInstance); |
| EasyAntReport eaReport = null; |
| try { |
| |
| ResolveOptions resolveOptions = buildResolveOptions(conf); |
| final ResolveReport report = IvyContext.getContext().getIvy().getResolveEngine() |
| .resolve(moduleRevisionId, resolveOptions, false); |
| eaReport = new EasyAntReport(); |
| eaReport.setResolveReport(report); |
| eaReport.setModuleDescriptor(report.getModuleDescriptor()); |
| |
| Project project = buildProject(); |
| // expose resolve report for import deferred |
| project.addReference(EasyAntMagicNames.IMPORTED_MODULES_RESOLVE_REPORT_REF, report); |
| |
| AbstractImport abstractImport = new AbstractImport() { |
| @Override |
| public void execute() throws BuildException { |
| Path path = createModulePath(moduleRevisionId.getModuleId()); |
| File antFile = null; |
| for (ArtifactDownloadReport artifact : report.getConfigurationReport(getMainConf()).getAllArtifactsReports()) { |
| if ("ant".equals(artifact.getType())) { |
| antFile = artifact.getLocalFile(); |
| } else if (shouldBeAddedToClasspath(artifact)) { |
| path.createPathElement().setLocation(artifact.getLocalFile()); |
| } else { |
| handleOtherResourceFile(moduleRevisionId, artifact.getName(), artifact.getExt(), |
| artifact.getLocalFile()); |
| } |
| } |
| if (antFile != null && antFile.exists()) { |
| ProjectHelper.configureProject(getProject(), antFile); |
| } |
| } |
| }; |
| |
| abstractImport.setProject(project); |
| // location ? |
| abstractImport.execute(); |
| |
| analyseProject(project, eaReport, conf); |
| } catch (Exception e) { |
| throw new Exception("An error occured while fetching plugin informations : " + e.getMessage(), e); |
| } finally { |
| IvyContext.popContext(); |
| } |
| return eaReport; |
| |
| } |
| |
| private Project buildProject() { |
| Project project = new Project(); |
| project.setNewProperty(EasyAntMagicNames.AUDIT_MODE, "true"); |
| project.setNewProperty(EasyAntMagicNames.SKIP_CORE_REVISION_CHECKER, "true"); |
| project.addReference(EasyAntMagicNames.EASYANT_IVY_INSTANCE, easyantIvySettings); |
| |
| TaskCollectorFromImplicitTargetListener listener = new TaskCollectorFromImplicitTargetListener(); |
| listener.addClassToCollect(ParameterTask.class); |
| listener.addClassToCollect(Property.class); |
| listener.addClassToCollect(Import.class); |
| listener.addClassToCollect(ImportDeferred.class); |
| listener.addClassToCollect(Path.class); |
| listener.addClassToCollect(PathTask.class); |
| listener.addClassToCollect(FileSet.class); |
| project.addBuildListener(listener); |
| |
| // add a property helper to ignore basedir property on reports |
| PropertyHelper propertyHelper = PropertyHelper.getPropertyHelper(project); |
| propertyHelper.add(new BypassDefaultPropertyExpander()); |
| |
| project.init(); |
| ProjectUtils.configureProjectHelper(project); |
| return project; |
| } |
| |
| private void analyseProject(Project project, EasyAntReport eaReport, String conf) throws Exception { |
| |
| // handle tasks from implicit target |
| // When using import/include, ant create a "implicit target" to process root tasks. When tasks are declared |
| // outside of a target in root project we are able to parse them "normally" as this implicit target is added to |
| // the project. However this is not the case for tasks declared outside any target in imported build script. |
| // So we use a listener to collect required informations |
| for (BuildListener buildListener : project.getBuildListeners()) { |
| if (buildListener instanceof TaskCollectorFromImplicitTargetListener) { |
| TaskCollectorFromImplicitTargetListener taskCollectorFromImplicitTargetListener = (TaskCollectorFromImplicitTargetListener) buildListener; |
| for (Task task : taskCollectorFromImplicitTargetListener.getTasksCollected()) { |
| handleTask(project, eaReport, conf, task); |
| } |
| } |
| } |
| |
| // handle tasks declared in targets |
| Map<String, Target> targets = ProjectUtils.removeDuplicateTargets(project.getTargets()); |
| for (Target target : targets.values()) { |
| if (!"".equals(target.getName())) { |
| // gather root module location from target if no task at root level was defined |
| TaskCollectorFromImplicitTargetListener.gatherRootModuleLocation(target.getProject(), |
| target.getLocation()); |
| handleTarget(target, eaReport); |
| for (int i = 0; i < target.getTasks().length; i++) { |
| Task task = target.getTasks()[i]; |
| handleTask(project, eaReport, conf, task); |
| } |
| } |
| } |
| } |
| |
| private Object maybeConfigureTask(Task task) { |
| if (task.getRuntimeConfigurableWrapper().getProxy() instanceof UnknownElement) { |
| UnknownElement ue = (UnknownElement) task.getRuntimeConfigurableWrapper().getProxy(); |
| ue.maybeConfigure(); |
| return ue.getRealThing(); |
| } else if (task instanceof UnknownElement) { |
| UnknownElement ue = (UnknownElement) task; |
| ue.maybeConfigure(); |
| return ue.getRealThing(); |
| } else { |
| return task; |
| } |
| } |
| |
| private void handleTask(Project project, EasyAntReport eaReport, String conf, Task task) throws Exception { |
| Class<?> taskClass = ComponentHelper.getComponentHelper(project).getComponentClass(task.getTaskType()); |
| if (taskClass != null) { |
| if (ParameterTask.class.isAssignableFrom(taskClass)) { |
| ParameterTask parameterTask = (ParameterTask) maybeConfigureTask(task); |
| handleParameterTask(parameterTask, eaReport); |
| } |
| if (Property.class.isAssignableFrom(taskClass)) { |
| Property propertyTask = (Property) maybeConfigureTask(task); |
| handleProperty(propertyTask, eaReport); |
| } |
| if (Import.class.isAssignableFrom(taskClass)) { |
| Import importTask = (Import) maybeConfigureTask(task); |
| handleImport(importTask, eaReport, conf); |
| } |
| |
| if (ImportDeferred.class.isAssignableFrom(taskClass)) { |
| ImportDeferred importTask = (ImportDeferred) maybeConfigureTask(task); |
| handleImportDeferred(importTask, eaReport, conf); |
| } |
| if (Path.class.isAssignableFrom(taskClass)) { |
| Path path = (Path) maybeConfigureTask(task); |
| handlePathParameter(task.getRuntimeConfigurableWrapper().getId(), path, task.getOwningTarget(), |
| eaReport); |
| } |
| if (PathTask.class.isAssignableFrom(taskClass)) { |
| PathTask pathTask = (PathTask) maybeConfigureTask(task); |
| handlePathParameter(pathTask, eaReport); |
| } |
| if (FileSet.class.isAssignableFrom(taskClass)) { |
| FileSet fileSet = (FileSet) maybeConfigureTask(task); |
| handleFilesetParameter(task.getRuntimeConfigurableWrapper().getId(), fileSet, task.getOwningTarget(), |
| eaReport); |
| } |
| } |
| } |
| |
| private boolean isCurrentModule(Project project, Location location) { |
| String rootModuleLocation = project.getProperty(TaskCollectorFromImplicitTargetListener.ROOT_MODULE_LOCATION); |
| if (rootModuleLocation == null) { |
| throw new IllegalStateException( |
| "rootModuleLocation not found, looks like TaskCollectorFromImplicitTargetListener is not properly configured"); |
| } |
| return location != null && location.getFileName().equals(rootModuleLocation); |
| } |
| |
| private void handleImport(Import importTask, EasyAntReport eaReport, String conf) throws Exception { |
| ImportedModuleReport importedModuleReport = new ImportedModuleReport(); |
| |
| importedModuleReport.setModuleMrid(importTask.getMrid()); |
| importedModuleReport.setOrganisation(importTask.getOrganisation()); |
| importedModuleReport.setModule(importTask.getModule()); |
| importedModuleReport.setRevision(importTask.getRevision()); |
| importedModuleReport.setMandatory(importTask.isMandatory()); |
| importedModuleReport.setMode(importTask.getMode()); |
| importedModuleReport.setAs(importTask.getAs()); |
| |
| EasyAntReport pluginInfo = getPluginInfo(ModuleRevisionId.parse(importedModuleReport.getModuleMrid()), conf); |
| importedModuleReport.setEasyantReport(pluginInfo); |
| eaReport.addImportedModuleReport(importedModuleReport, |
| isCurrentModule(importTask.getProject(), importTask.getLocation())); |
| |
| Message.debug("Ant file import another module called : " + importedModuleReport.getModuleMrid() + " with mode " |
| + importedModuleReport.getMode()); |
| } |
| |
| private void handleImportDeferred(ImportDeferred importTask, EasyAntReport eaReport, String conf) throws Exception { |
| ImportedModuleReport importedModuleReport = new ImportedModuleReport(); |
| |
| importedModuleReport.setOrganisation(importTask.getOrganisation()); |
| importedModuleReport.setModule(importTask.getModule()); |
| ResolveReport resolveReport = importTask.getProject().getReference( |
| EasyAntMagicNames.IMPORTED_MODULES_RESOLVE_REPORT_REF); |
| if (resolveReport != null) { |
| for (Object o : resolveReport.getDependencies()) { |
| IvyNode dependency = (IvyNode) o; |
| if (dependency.getResolvedId().getOrganisation().equals(importTask.getOrganisation()) // |
| && dependency.getResolvedId().getName().equals(importTask.getModule())) { |
| importedModuleReport.setRevision(dependency.getResolvedId().getRevision()); |
| } |
| |
| } |
| } |
| |
| importedModuleReport.setMandatory(importTask.isMandatory()); |
| importedModuleReport.setMode(importTask.getMode()); |
| importedModuleReport.setAs(importTask.getAs()); |
| |
| EasyAntReport pluginInfo = getPluginInfo(ModuleRevisionId.parse(importedModuleReport.getModuleMrid()), conf); |
| importedModuleReport.setEasyantReport(pluginInfo); |
| eaReport.addImportedModuleReport(importedModuleReport, |
| isCurrentModule(importTask.getProject(), importTask.getLocation())); |
| |
| Message.debug("Ant file import another module called : " + importedModuleReport.getModuleMrid() + " with mode " |
| + importedModuleReport.getMode()); |
| } |
| |
| private void handleProperty(Property property, EasyAntReport eaReport) throws IOException { |
| boolean isCurrentModule = isCurrentModule(property.getProject(), property.getLocation()); |
| if (property.getFile() != null) { |
| Properties propToLoad = new Properties(); |
| File f = property.getFile(); |
| if (f.exists()) { |
| FileInputStream fis = null; |
| |
| try { |
| fis = new FileInputStream(f); |
| propToLoad.load(fis); |
| for (Object o : propToLoad.keySet()) { |
| String key = (String) o; |
| PropertyDescriptor propertyDescriptor = new PropertyDescriptor(key); |
| propertyDescriptor.setValue(propToLoad.getProperty(key)); |
| if (property.getOwningTarget() != null) { |
| propertyDescriptor.setOwningTarget(property.getOwningTarget().getName()); |
| } |
| eaReport.addPropertyDescriptor(propertyDescriptor.getName(), propertyDescriptor, |
| isCurrentModule); |
| } |
| |
| } catch (IOException e) { |
| IOException ioe = new IOException("Unable to parse the property file :" + property.getFile()); |
| ioe.initCause(e); |
| throw ioe; |
| } finally { |
| if (fis != null) { |
| fis.close(); |
| } |
| } |
| } |
| |
| } |
| if (property.getName() != null) { |
| PropertyDescriptor propertyDescriptor = new PropertyDescriptor(property.getName()); |
| propertyDescriptor.setValue(property.getValue()); |
| if (property.getOwningTarget() != null) { |
| propertyDescriptor.setOwningTarget(property.getOwningTarget().getName()); |
| } |
| eaReport.addPropertyDescriptor(property.getName(), propertyDescriptor, isCurrentModule); |
| } |
| } |
| |
| private void handleParameterTask(ParameterTask parameterTask, EasyAntReport eaReport) { |
| boolean isCurrentModule = isCurrentModule(parameterTask.getProject(), parameterTask.getLocation()); |
| |
| if (parameterTask.getProperty() != null) { |
| PropertyDescriptor propertyDescriptor = new PropertyDescriptor(parameterTask.getProperty()); |
| propertyDescriptor.setDefaultValue(parameterTask.getDefault()); |
| // Use unsafe version since we are in audit mode and we want the real value of the required field |
| // (#isRequired method will always return false in audit mode) |
| propertyDescriptor.setRequired(parameterTask.isRequiredUnsafe()); |
| propertyDescriptor.setDescription(parameterTask.getDescription()); |
| if (parameterTask.getOwningTarget() != null) { |
| propertyDescriptor.setOwningTarget(parameterTask.getOwningTarget().getName()); |
| } |
| Message.debug("Ant file has a property called : " + propertyDescriptor.getName()); |
| eaReport.addPropertyDescriptor(propertyDescriptor.getName(), propertyDescriptor, isCurrentModule); |
| } else if (parameterTask.getPath() != null) { |
| ParameterReport parameterReport = new ParameterReport(ParameterType.PATH); |
| parameterReport.setName(parameterTask.getPath()); |
| // Use unsafe version since we are in audit mode and we want the real value of the required field |
| // (#isRequired method will always return false in audit mode) |
| parameterReport.setRequired(parameterTask.isRequiredUnsafe()); |
| parameterReport.setDescription(parameterTask.getDescription()); |
| if (parameterTask.getOwningTarget() != null) { |
| parameterReport.setOwningTarget(parameterTask.getOwningTarget().getName()); |
| } |
| eaReport.addParameterReport(parameterReport, isCurrentModule); |
| Message.debug("Ant file has a path called : " + parameterReport.getName()); |
| } |
| } |
| |
| private void handleFilesetParameter(String id, FileSet fileSet, Target target, EasyAntReport eaReport) { |
| ParameterReport parameterReport = new ParameterReport(ParameterType.FILESET); |
| if (id != null) { |
| parameterReport.setName(id); |
| parameterReport.setRequired(false); |
| parameterReport.setDescription(fileSet.getDescription()); |
| if (target != null) { |
| parameterReport.setOwningTarget(target.getName()); |
| } |
| eaReport.addParameterReport(parameterReport, isCurrentModule(fileSet.getProject(), fileSet.getLocation())); |
| Message.debug("Ant file has a fileset called : " + parameterReport.getName()); |
| } |
| |
| } |
| |
| private void handlePathParameter(String pathid, Path path, Target target, EasyAntReport eaReport) { |
| ParameterReport parameterReport = new ParameterReport(ParameterType.PATH); |
| if (pathid != null) { |
| parameterReport.setName(pathid); |
| parameterReport.setRequired(false); |
| parameterReport.setDescription(path.getDescription()); |
| if (target != null) { |
| parameterReport.setOwningTarget(target.getName()); |
| } |
| eaReport.addParameterReport(parameterReport, isCurrentModule(path.getProject(), path.getLocation())); |
| Message.debug("Ant file has a path called : " + parameterReport.getName()); |
| } |
| } |
| |
| private void handlePathParameter(PathTask pathTask, EasyAntReport eaReport) { |
| ParameterReport parameterReport = new ParameterReport(ParameterType.PATH); |
| if (pathTask.getPathid() != null) { |
| parameterReport.setName(pathTask.getPathid()); |
| parameterReport.setRequired(false); |
| parameterReport.setDescription(pathTask.getDescription()); |
| if (pathTask.getOwningTarget() != null) { |
| parameterReport.setOwningTarget(pathTask.getOwningTarget().getName()); |
| } |
| eaReport.addParameterReport(parameterReport, isCurrentModule(pathTask.getProject(), pathTask.getLocation())); |
| Message.debug("Ant file has a path called : " + parameterReport.getName()); |
| } |
| } |
| |
| private void handleTarget(Target target, EasyAntReport eaReport) { |
| boolean isCurrentModule = isCurrentModule(target.getProject(), target.getLocation()); |
| boolean isExtensionPoint = target instanceof ExtensionPoint; |
| if (!isExtensionPoint) { |
| TargetReport targetReport = new TargetReport(); |
| targetReport.setName(target.getName()); |
| StringBuilder sb = new StringBuilder(); |
| Enumeration<?> targetDeps = target.getDependencies(); |
| while (targetDeps.hasMoreElements()) { |
| String t = (String) targetDeps.nextElement(); |
| sb.append(t); |
| if (targetDeps.hasMoreElements()) { |
| sb.append(","); |
| } |
| } |
| targetReport.setDepends(sb.toString()); |
| targetReport.setDescription(target.getDescription()); |
| targetReport.setIfCase(target.getIf()); |
| targetReport.setUnlessCase(target.getUnless()); |
| for (Target currentTarget : target.getProject().getTargets().values()) { |
| if (currentTarget instanceof ExtensionPoint) { |
| Enumeration<?> dependencies = currentTarget.getDependencies(); |
| while (dependencies.hasMoreElements()) { |
| String dep = (String) dependencies.nextElement(); |
| if (dep.equals(target.getName())) { |
| targetReport.setExtensionPoint(currentTarget.getName()); |
| } |
| } |
| |
| } |
| } |
| |
| eaReport.addTargetReport(targetReport, isCurrentModule); |
| |
| Message.debug("Ant file has a target called : " + targetReport.getName()); |
| } else { |
| ExtensionPointReport extensionPoint = new ExtensionPointReport(target.getName()); |
| StringBuilder sb = new StringBuilder(); |
| Enumeration<?> targetDeps = target.getDependencies(); |
| while (targetDeps.hasMoreElements()) { |
| String t = (String) targetDeps.nextElement(); |
| sb.append(t); |
| if (targetDeps.hasMoreElements()) { |
| sb.append(","); |
| } |
| } |
| extensionPoint.setDepends(sb.toString()); |
| extensionPoint.setDescription(target.getDescription()); |
| eaReport.addExtensionPointReport(extensionPoint, isCurrentModule); |
| Message.debug("Ant file has an extensionPoint called : " + extensionPoint.getName()); |
| } |
| } |
| |
| public EasyAntReport getPluginInfo(ModuleRevisionId moduleRevisionId) throws Exception { |
| return getPluginInfo(moduleRevisionId, "default"); |
| } |
| |
| public EasyAntReport getPluginInfo(String moduleRevisionId) throws Exception { |
| ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.PLUGIN); |
| return getPluginInfo(module); |
| } |
| |
| public EasyAntReport getBuildTypeInfo(String moduleRevisionId) throws Exception { |
| ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.BUILDTYPE); |
| return getPluginInfo(module); |
| } |
| |
| public EasyAntModuleDescriptor getEasyAntModuleDescriptor(File moduleDescriptor) throws Exception { |
| if (moduleDescriptor == null) { |
| throw new Exception("moduleDescriptor cannot be null"); |
| } |
| if (!moduleDescriptor.exists()) { |
| throw new Exception("imposible to find the specified module descriptor" |
| + moduleDescriptor.getAbsolutePath()); |
| } |
| IvyContext.pushNewContext().setIvy(ivyInstance); |
| // First we need to parse the specified file to retrieve all the easyant |
| // stuff |
| parser.parseDescriptor(ivyInstance.getSettings(), moduleDescriptor.toURI().toURL(), new URLResource( |
| moduleDescriptor.toURI().toURL()), true); |
| EasyAntModuleDescriptor md = parser.getEasyAntModuleDescriptor(); |
| IvyContext.popContext(); |
| return md; |
| } |
| |
| public EasyAntReport generateEasyAntReport(File moduleDescriptor, File optionalAntModule, File overrideAntModule) |
| throws Exception { |
| EasyAntReport eaReport = new EasyAntReport(); |
| EasyAntModuleDescriptor md = getEasyAntModuleDescriptor(moduleDescriptor); |
| eaReport.setModuleDescriptor(md.getIvyModuleDescriptor()); |
| |
| Project p = buildProject(); |
| Target implicitTarget = ProjectUtils.createTopLevelTarget(); |
| p.addTarget(implicitTarget); |
| |
| // calculate basedir |
| if (moduleDescriptor != null) { |
| p.setBaseDir(moduleDescriptor.getParentFile()); |
| } else if (optionalAntModule != null) { |
| p.setBaseDir(optionalAntModule.getParentFile()); |
| } else if (overrideAntModule != null) { |
| p.setBaseDir(overrideAntModule.getParentFile()); |
| } |
| |
| LoadModule loadModule = new LoadModule(); |
| loadModule.setBuildModule(moduleDescriptor); |
| loadModule.setBuildFile(optionalAntModule); |
| loadModule.setOwningTarget(implicitTarget); |
| loadModule.setLocation(new Location(ProjectUtils.emulateMainScript(p).getAbsolutePath())); |
| loadModule.setProject(p); |
| loadModule.setTaskName("load-module"); |
| loadModule.execute(); |
| ProjectHelper projectHelper = ProjectUtils.getConfiguredProjectHelper(p); |
| projectHelper.resolveExtensionOfAttributes(p); |
| analyseProject(p, eaReport, "default"); |
| |
| return eaReport; |
| } |
| |
| public ModuleRevisionId[] search(String organisation, String moduleName, String revision, String branch, |
| String matcher, String resolver) throws Exception { |
| IvySettings settings = ivyInstance.getSettings(); |
| |
| if (moduleName == null && PatternMatcher.EXACT.equals(matcher)) { |
| throw new Exception("no module name provided for ivy repository graph task: " |
| + "It can either be set explicitely via the attribute 'module' or " |
| + "via 'ivy.module' property or a prior call to <resolve/>"); |
| } else if (moduleName == null && !PatternMatcher.EXACT.equals(matcher)) { |
| moduleName = PatternMatcher.ANY_EXPRESSION; |
| } |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance(organisation, moduleName, revision); |
| |
| ModuleRevisionId criteria; |
| |
| if ((revision == null) || settings.getVersionMatcher().isDynamic(mrid)) { |
| criteria = new ModuleRevisionId(new ModuleId(organisation, moduleName), branch, "*"); |
| } else { |
| criteria = new ModuleRevisionId(new ModuleId(organisation, moduleName), branch, revision); |
| } |
| |
| PatternMatcher patternMatcher = settings.getMatcher(matcher); |
| if (PatternMatcher.ANY_EXPRESSION.equals(resolver)) { |
| // search in all resolvers. this can be quite slow for complex |
| // repository configurations |
| // with ChainResolvers, since resolvers in chains will be searched |
| // multiple times. |
| return ivyInstance.listModules(criteria, patternMatcher); |
| } else { |
| // limit search to the specified resolver. |
| DependencyResolver dependencyResolver = resolver == null ? settings.getDefaultResolver() : settings |
| .getResolver(resolver); |
| if (dependencyResolver == null) { |
| throw new IllegalArgumentException("Unknown dependency resolver for search: " + resolver); |
| } |
| |
| ivyInstance.pushContext(); |
| try { |
| return ivyInstance.getSearchEngine().listModules(dependencyResolver, criteria, patternMatcher); |
| } finally { |
| ivyInstance.popContext(); |
| } |
| } |
| } |
| |
| public ModuleRevisionId[] search(String organisation, String moduleName) throws Exception { |
| return search(organisation, moduleName, null, null, PatternMatcher.EXACT_OR_REGEXP, null); |
| } |
| |
| public String[] searchModule(String organisation, String moduleName) throws Exception { |
| ModuleRevisionId[] mrids = search(organisation, moduleName); |
| String[] result = new String[mrids.length]; |
| for (int i = 0; i < mrids.length; i++) { |
| result[i] = mrids[i].toString(); |
| } |
| return result; |
| } |
| |
| public String getDescription(ModuleRevisionId mrid) { |
| ResolvedModuleRevision rmr = ivyInstance.findModule(mrid); |
| return rmr.getDescriptor().getDescription(); |
| } |
| |
| public String getPluginDescription(String moduleRevisionId) { |
| ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.PLUGIN); |
| return getDescription(module); |
| } |
| |
| public String getBuildTypeDescription(String moduleRevisionId) { |
| ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.BUILDTYPE); |
| |
| return getDescription(module); |
| } |
| |
| private ModuleRevisionId buildModuleRevisionId(String moduleRevisionId, PluginType pluginType) { |
| String mrid = moduleRevisionId; |
| if (!mrid.matches(".*#.*")) { |
| if (pluginType.equals(PluginType.BUILDTYPE)) { |
| Message.debug("No organisation specified for buildtype " + mrid + " using the default one"); |
| |
| mrid = EasyAntConstants.EASYANT_BUILDTYPES_ORGANISATION + "#" + mrid; |
| |
| } else { |
| Message.debug("No organisation specified for plugin " + mrid + " using the default one"); |
| |
| mrid = EasyAntConstants.EASYANT_PLUGIN_ORGANISATION + "#" + mrid; |
| } |
| } |
| return ModuleRevisionId.parse(mrid); |
| } |
| |
| public EasyAntReport generateEasyAntReport(File moduleDescriptor) throws Exception { |
| return generateEasyAntReport(moduleDescriptor, null, null); |
| } |
| |
| /** |
| * Don't try to expand property on reports. Bypassing default property expander allow us to show real static value |
| * of properties on reports. |
| */ |
| private class BypassDefaultPropertyExpander implements PropertyExpander { |
| |
| public String parsePropertyName(String s, ParsePosition pos, ParseNextProperty notUsed) { |
| int index = pos.getIndex(); |
| // directly check near, triggering characters: |
| if (s.length() - index >= 3 && '$' == s.charAt(index) && '{' == s.charAt(index + 1)) { |
| int start = index; |
| |
| // defer to String.indexOf() for protracted check: |
| int end = s.indexOf('}', start); |
| if (end < 0) { |
| throw new BuildException("Syntax error in property: " + s.substring(index)); |
| } |
| |
| // set marker after "}" |
| pos.setIndex(end + 1); |
| |
| // allow to resolve path to property files |
| // this is mandatory if we want report to contains properties loaded by |
| // property file like done on buildtypes |
| // in that case property needs to be really expanded so we need to strips "${" and "}" characters |
| String strippedPropertyName = s.substring(start + 2, end); |
| if (strippedPropertyName.endsWith("properties.file")) { |
| |
| return strippedPropertyName; |
| } |
| |
| // in other cases return the whole property with "${" and "}" |
| return start == end ? "" : s.substring(start, end + 1); |
| } |
| return null; |
| } |
| } |
| |
| public void setOfflineMode(boolean offlineMode) { |
| this.offlineMode = offlineMode; |
| } |
| } |
