diff options
Diffstat (limited to 'org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/ProjectConfigurationManager.java')
-rw-r--r-- | org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/ProjectConfigurationManager.java | 716 |
1 files changed, 716 insertions, 0 deletions
diff --git a/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/ProjectConfigurationManager.java b/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/ProjectConfigurationManager.java new file mode 100644 index 00000000..1c48f23b --- /dev/null +++ b/org.eclipse.m2e.core/src/org/eclipse/m2e/core/internal/project/ProjectConfigurationManager.java @@ -0,0 +1,716 @@ +/******************************************************************************* + * Copyright (c) 2008-2010 Sonatype, Inc. + * 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: + * Sonatype, Inc. - initial API and implementation + *******************************************************************************/ + +package org.eclipse.m2e.core.internal.project; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Properties; +import java.util.Set; + +import org.osgi.framework.Bundle; +import org.osgi.framework.Version; + +import org.eclipse.core.resources.ICommand; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IFolder; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IProjectDescription; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IWorkspace; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.OperationCanceledException; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.SubMonitor; +import org.eclipse.core.runtime.jobs.ISchedulingRule; +import org.eclipse.osgi.util.NLS; +import org.eclipse.ui.IWorkingSet; + +import org.codehaus.plexus.util.StringUtils; + +import org.apache.maven.archetype.ArchetypeGenerationRequest; +import org.apache.maven.archetype.ArchetypeGenerationResult; +import org.apache.maven.archetype.catalog.Archetype; +import org.apache.maven.artifact.Artifact; +import org.apache.maven.artifact.repository.ArtifactRepository; +import org.apache.maven.execution.MavenExecutionRequest; +import org.apache.maven.execution.MavenSession; +import org.apache.maven.model.Model; +import org.apache.maven.plugin.MojoExecution; +import org.apache.maven.project.MavenProject; + +import org.eclipse.m2e.core.MavenPlugin; +import org.eclipse.m2e.core.archetype.ArchetypeCatalogFactory.RemoteCatalogFactory; +import org.eclipse.m2e.core.archetype.ArchetypeManager; +import org.eclipse.m2e.core.core.IMavenConstants; +import org.eclipse.m2e.core.core.MavenConsole; +import org.eclipse.m2e.core.core.MavenLogger; +import org.eclipse.m2e.core.embedder.IMaven; +import org.eclipse.m2e.core.embedder.IMavenConfiguration; +import org.eclipse.m2e.core.embedder.MavenModelManager; +import org.eclipse.m2e.core.internal.Messages; +import org.eclipse.m2e.core.project.IMavenMarkerManager; +import org.eclipse.m2e.core.project.IMavenProjectChangedListener; +import org.eclipse.m2e.core.project.IMavenProjectFacade; +import org.eclipse.m2e.core.project.IMavenProjectImportResult; +import org.eclipse.m2e.core.project.IProjectConfigurationManager; +import org.eclipse.m2e.core.project.LocalProjectScanner; +import org.eclipse.m2e.core.project.MavenProjectChangedEvent; +import org.eclipse.m2e.core.project.MavenProjectInfo; +import org.eclipse.m2e.core.project.MavenProjectManager; +import org.eclipse.m2e.core.project.MavenUpdateRequest; +import org.eclipse.m2e.core.project.ProjectImportConfiguration; +import org.eclipse.m2e.core.project.ResolverConfiguration; +import org.eclipse.m2e.core.project.configurator.AbstractProjectConfigurator; +import org.eclipse.m2e.core.project.configurator.ILifecycleMapping; +import org.eclipse.m2e.core.project.configurator.ProjectConfigurationRequest; +import org.eclipse.m2e.core.util.Util; + +/** + * import Maven projects + * update project configuration from Maven + * enable Maven nature + * create new project + * + * @author igor + */ +public class ProjectConfigurationManager implements IProjectConfigurationManager, IMavenProjectChangedListener { + + final MavenConsole console; + + final MavenProjectManager projectManager; + + final MavenModelManager mavenModelManager; + + final IMavenMarkerManager mavenMarkerManager; + + final IMaven maven; + + final IMavenConfiguration mavenConfiguration; + + public ProjectConfigurationManager(IMaven maven, MavenConsole console, MavenProjectManager projectManager, + MavenModelManager mavenModelManager, IMavenMarkerManager mavenMarkerManager, IMavenConfiguration mavenConfiguration) { + this.console = console; + this.projectManager = projectManager; + this.mavenModelManager = mavenModelManager; + this.mavenMarkerManager = mavenMarkerManager; + this.maven = maven; + this.mavenConfiguration = mavenConfiguration; + } + + public List<IMavenProjectImportResult> importProjects(Collection<MavenProjectInfo> projectInfos, ProjectImportConfiguration configuration, IProgressMonitor monitor) throws CoreException { + long t1 = System.currentTimeMillis(); + + SubMonitor progress = SubMonitor.convert(monitor, Messages.ProjectConfigurationManager_task_importing, 100); + + ArrayList<IMavenProjectImportResult> result = new ArrayList<IMavenProjectImportResult>(); + ArrayList<IProject> projects = new ArrayList<IProject>(); + + SubMonitor subProgress = + SubMonitor.convert( progress.newChild( 10 ), projectInfos.size() * 100 ); + + // first, create all projects with basic configuration + for(MavenProjectInfo projectInfo : projectInfos) { + if(monitor.isCanceled()) { + throw new OperationCanceledException(); + } + + IProject project = create(projectInfo, configuration, subProgress.newChild(100)); + + result.add(new MavenProjectImportResult(projectInfo, project)); + + if (project != null) { + projects.add(project); + + addToWorkingSets(project, configuration.getWorkingSets()); + } + } + + hideNestedProjectsFromParents(projects); + // then configure maven for all projects + configureNewMavenProject(projects, progress.newChild(90)); + + long t2 = System.currentTimeMillis(); + console.logMessage("Project import completed " + ((t2 - t1) / 1000) + " sec"); + + return result; + } + + + private void setHidden(IResource resource) { + // Invoke IResource.setHidden() through reflection since it is only avaiable in Eclispe 3.4 & later + try { + Method m = IResource.class.getMethod("setHidden", boolean.class); //$NON-NLS-1$ + m.invoke(resource, Boolean.TRUE); + } catch (Exception ex) { + MavenLogger.log("Failed to hide resource; " + resource.getLocation().toOSString(), ex); + } + } + + private void hideNestedProjectsFromParents(List<IProject> projects) { + + if (!MavenPlugin.getDefault().getMavenConfiguration().isHideFoldersOfNestedProjects()) { + return; + } + // Prevent child project folders from showing up in parent project folders. + + Bundle bundle = ResourcesPlugin.getPlugin().getBundle(); + String version = (String) bundle.getHeaders().get(org.osgi.framework.Constants.BUNDLE_VERSION); + Version currentVersion = org.osgi.framework.Version.parseVersion(version); + Version e34Version = new Version(3,4,0); + if (currentVersion.compareTo(e34Version) < 0) { + return; // IResource.setHidden doesn't exist in Eclipse prior to version 3.4 + } + HashMap<File, IProject> projectFileMap = new HashMap<File, IProject>(); + + for (IProject project: projects) { + projectFileMap.put(project.getLocation().toFile(), project); + } + for (IProject project: projects) { + File projectFile = project.getLocation().toFile(); + IProject physicalParentProject = projectFileMap.get(projectFile.getParentFile()); + if (physicalParentProject == null) { + continue; + } + IFolder folder = physicalParentProject.getFolder(projectFile.getName()); + if (folder.exists()) { + setHidden(folder); + } + } + } + + private void configureNewMavenProject(List<IProject> projects, IProgressMonitor monitor) + throws CoreException { + SubMonitor progress = SubMonitor.convert(monitor, Messages.ProjectConfigurationManager_task_configuring, 100); + + //SubProgressMonitor sub = new SubProgressMonitor(monitor, projects.size()+1); + + // first, resolve maven dependencies for all projects + MavenUpdateRequest updateRequest = new MavenUpdateRequest(mavenConfiguration.isOffline(), false); + for(IProject project : projects) { + updateRequest.addPomFile(project); + } + progress.subTask(Messages.ProjectConfigurationManager_task_refreshing); + projectManager.refresh(updateRequest, progress.newChild(75)); + + // TODO this emits project change events, which may be premature at this point + + //Creating maven facades + SubMonitor subProgress = SubMonitor.convert(progress.newChild(5), projects.size() * 100); + List<IMavenProjectFacade> facades = new ArrayList<IMavenProjectFacade>(projects.size()); + for(IProject project : projects) { + if(progress.isCanceled()) { + throw new OperationCanceledException(); + } + IMavenProjectFacade facade = projectManager.create(project, subProgress.newChild(100)); + if (facade != null) { + facades.add(facade); + } + } + + //MNGECLIPSE-1028 : Sort projects by build order here, + //as dependent projects need to be configured before depending projects (in WTP integration for ex.) + sortProjects(facades, progress.newChild(5)); + //Then, perform detailed project configuration + subProgress = SubMonitor.convert(progress.newChild(15), facades.size() * 100); + for(IMavenProjectFacade facade : facades) { + if(progress.isCanceled()) { + throw new OperationCanceledException(); + } + progress.subTask(NLS.bind(Messages.ProjectConfigurationManager_task_updating, facade.getProject().getName())); + MavenProject mavenProject = facade.getMavenProject(subProgress.newChild(5)); + MavenSession mavenSession = createMavenSession(facade, subProgress.newChild(5)); + ProjectConfigurationRequest request = new ProjectConfigurationRequest(facade, mavenProject, mavenSession, false /*updateSources*/); + updateProjectConfiguration(request, subProgress.newChild(90)); + } + } + + private MavenSession createMavenSession(IMavenProjectFacade facade, IProgressMonitor monitor) throws CoreException { + MavenExecutionRequest request = projectManager.createExecutionRequest(facade.getPom(), facade.getResolverConfiguration(), monitor); + return maven.createSession(request, facade.getMavenProject(monitor)); + } + + public void sortProjects(List<IMavenProjectFacade> facades, IProgressMonitor monitor) throws CoreException { + HashMap<MavenProject, IMavenProjectFacade> mavenProjectToFacadeMap = new HashMap<MavenProject, IMavenProjectFacade>(facades.size()); + for(IMavenProjectFacade facade:facades) { + mavenProjectToFacadeMap.put(facade.getMavenProject(monitor), facade); + } + facades.clear(); + for(MavenProject mavenProject: maven.getSortedProjects(new ArrayList<MavenProject>(mavenProjectToFacadeMap.keySet()))) { + facades.add(mavenProjectToFacadeMap.get(mavenProject)); + } + } + + // PlatformUI.getWorkbench().getWorkingSetManager().addToWorkingSets(project, new IWorkingSet[] {workingSet}); + private void addToWorkingSets(IProject project, IWorkingSet[] workingSets) { + if (workingSets != null && workingSets.length > 0) { + // IAdaptable[] elements = workingSet.adaptElements(new IAdaptable[] {project}); + // if(elements.length == 1) { + for (IWorkingSet workingSet : workingSets) { + IAdaptable[] oldElements = workingSet.getElements(); + IAdaptable[] newElements = new IAdaptable[oldElements.length + 1]; + System.arraycopy(oldElements, 0, newElements, 0, oldElements.length); + newElements[oldElements.length] = project; + + // Eclipse 3.2 compatibility + workingSet.setElements(Util.proxy(workingSet, A.class).adaptElements(newElements)); + // } + } + } + } + + /** + * A compatibility proxy stub + */ + private static interface A { + public IAdaptable[] adaptElements(IAdaptable[] objects); + } + + public void updateProjectConfiguration(IProject project, ResolverConfiguration configuration, IProgressMonitor monitor) throws CoreException { + IFile pom = project.getFile(IMavenConstants.POM_FILE_NAME); + if (pom.isAccessible()) { + projectManager.refresh(new MavenUpdateRequest(project, mavenConfiguration.isOffline(), false), monitor); + IMavenProjectFacade facade = projectManager.create(pom, false, monitor); + if (facade != null) { // facade is null if pom.xml cannot be read + ProjectConfigurationRequest request = new ProjectConfigurationRequest(facade, facade.getMavenProject(monitor), createMavenSession(facade, monitor), true /*updateSources*/); + updateProjectConfiguration(request, monitor); + } + } + } + + private void updateProjectConfiguration(ProjectConfigurationRequest request, + IProgressMonitor monitor) throws CoreException { + IProject project = request.getProject(); + addMavenNature(project, monitor); + + IMavenProjectFacade mavenProjectFacade = request.getMavenProjectFacade(); + validateProjectConfiguration(mavenProjectFacade, monitor); + + ILifecycleMapping lifecycleMapping = getLifecycleMapping(mavenProjectFacade, monitor); + lifecycleMapping.configure(request, monitor); + } + + /* (non-Javadoc) + * @see org.eclipse.m2e.core.project.IProjectConfigurationManager#validateProjectConfiguration(org.eclipse.m2e.core.project.IMavenProjectFacade, org.eclipse.core.runtime.IProgressMonitor) + */ + public boolean validateProjectConfiguration(IMavenProjectFacade mavenProjectFacade, IProgressMonitor monitor) { + try { + mavenProjectFacade.setHasValidConfiguration(false); + mavenMarkerManager.deleteMarkers(mavenProjectFacade.getPom(), IMavenConstants.MARKER_CONFIGURATION_ID); + + ILifecycleMapping lifecycleMapping = getLifecycleMapping(mavenProjectFacade, monitor); + if(lifecycleMapping == null || lifecycleMapping instanceof MissingLifecycleMapping) { + String lifecycleId = null; + if(lifecycleMapping != null) { + lifecycleId = lifecycleMapping.getId(); + } + mavenMarkerManager.addMarker(mavenProjectFacade.getPom(), IMavenConstants.MARKER_CONFIGURATION_ID, + NLS.bind(Messages.LifecycleMissing, lifecycleId, mavenProjectFacade.getPackaging()), 1 /*lineNumber*/, + IMarker.SEVERITY_ERROR); + return false; + } + + List<MojoExecution> notCoveredMojoExecutions = lifecycleMapping.getNotCoveredMojoExecutions(mavenProjectFacade, + monitor); + if(notCoveredMojoExecutions != null && notCoveredMojoExecutions.size() != 0) { + for(MojoExecution mojoExecution : notCoveredMojoExecutions) { + mavenMarkerManager.addMarker( + mavenProjectFacade.getPom(), + IMavenConstants.MARKER_CONFIGURATION_ID, + NLS.bind(Messages.LifecycleConfigurationMojoExecutionNotCovered, mojoExecution.toString(), + mojoExecution.getLifecyclePhase()), 1 /*lineNumber*/, IMarker.SEVERITY_ERROR); + } + return false; + } + mavenProjectFacade.setHasValidConfiguration(true); + return true; + } catch(CoreException e) { + mavenMarkerManager.addErrorMarkers(mavenProjectFacade.getPom(), IMavenConstants.MARKER_CONFIGURATION_ID, e); + return false; + } + } + + public void enableMavenNature(IProject project, ResolverConfiguration configuration, IProgressMonitor monitor) + throws CoreException { + monitor.subTask(Messages.ProjectConfigurationManager_task_enable_nature); + enableBasicMavenNature(project, configuration, monitor); + + ArrayList<IProject> projects = new ArrayList<IProject>(); + projects.add(project); + configureNewMavenProject(projects, monitor); + } + + private void enableBasicMavenNature(IProject project, ResolverConfiguration configuration, IProgressMonitor monitor) + throws CoreException { + projectManager.setResolverConfiguration(project, configuration); + + // add maven nature even for projects without valid pom.xml file + addMavenNature(project, monitor); + } + + private void addMavenNature(IProject project, IProgressMonitor monitor) throws CoreException { + if (!project.hasNature(IMavenConstants.NATURE_ID)) { + IProjectDescription description = project.getDescription(); + String[] prevNatures = description.getNatureIds(); + String[] newNatures = new String[prevNatures.length + 1]; + System.arraycopy(prevNatures, 0, newNatures, 1, prevNatures.length); + newNatures[0] = IMavenConstants.NATURE_ID; + description.setNatureIds(newNatures); + project.setDescription(description, monitor); + } + } + + public void disableMavenNature(IProject project, IProgressMonitor monitor) throws CoreException { + monitor.subTask(Messages.ProjectConfigurationManager_task_disable_nature); + + IMavenProjectFacade facade = projectManager.create(project, monitor); + if(facade!=null) { + ILifecycleMapping lifecycleMapping = getLifecycleMapping(facade, monitor); + ProjectConfigurationRequest request = new ProjectConfigurationRequest(facade, facade.getMavenProject(monitor), createMavenSession(facade, monitor), false /*updateSources*/); + lifecycleMapping.unconfigure(request, monitor); + } + + project.deleteMarkers(IMavenConstants.MARKER_ID, true, IResource.DEPTH_INFINITE); + + IProjectDescription description = project.getDescription(); + ArrayList<String> newNatures = new ArrayList<String>(); + for(String natureId : description.getNatureIds()) { + if(!IMavenConstants.NATURE_ID.equals(natureId)) { + newNatures.add(natureId); + } + } + description.setNatureIds(newNatures.toArray(new String[newNatures.size()])); + ArrayList<ICommand> newCommands = new ArrayList<ICommand>(); + for (ICommand command : description.getBuildSpec()) { + if (!IMavenConstants.BUILDER_ID.equals(command.getBuilderName())) { + newCommands.add(command); + } + } + description.setBuildSpec(newCommands.toArray(new ICommand[newCommands.size()])); + project.setDescription(description, null); + } + + // project creation + + /** + * Creates simple Maven project + * <p> + * The following steps are executed in the given order: + * <ul> + * <li>Creates the workspace project</li> + * <li>Adds project to working set</li> + * <li>Creates the required folders</li> + * <li>Creates the POM</li> + * <li>Configures project</li> + * </ul> + * </p> + */ + // XXX should use Maven plugin configurations instead of manually specifying folders + public void createSimpleProject(IProject project, IPath location, Model model, String[] directories, + ProjectImportConfiguration configuration, IProgressMonitor monitor) throws CoreException { + String projectName = project.getName(); + monitor.beginTask(NLS.bind(Messages.ProjectConfigurationManager_task_creating, projectName), 5); + + monitor.subTask(Messages.ProjectConfigurationManager_task_creating_workspace); + IProjectDescription description = ResourcesPlugin.getWorkspace().newProjectDescription(projectName); + description.setLocation(location); + project.create(description, monitor); + project.open(monitor); + monitor.worked(1); + + addToWorkingSets(project, configuration.getWorkingSets()); + monitor.worked(1); + + monitor.subTask(Messages.ProjectConfigurationManager_task_creating_pom); + IFile pomFile = project.getFile(IMavenConstants.POM_FILE_NAME); + mavenModelManager.createMavenModel(pomFile, model); + monitor.worked(1); + + monitor.subTask(Messages.ProjectConfigurationManager_task_creating_folders); + for(int i = 0; i < directories.length; i++ ) { + Util.createFolder(project.getFolder(directories[i]), false); + } + monitor.worked(1); + + monitor.subTask(Messages.ProjectConfigurationManager_task_creating_project); + enableMavenNature(project, configuration.getResolverConfiguration(), monitor); + monitor.worked(1); + } + + /** + * Creates project structure using Archetype and then imports created project + */ + public void createArchetypeProject(IProject project, IPath location, Archetype archetype, String groupId, + String artifactId, String version, String javaPackage, Properties properties, + ProjectImportConfiguration configuration, IProgressMonitor monitor) throws CoreException { + monitor.beginTask(NLS.bind(Messages.ProjectConfigurationManager_task_creating_project1, project.getName()), 2); + + IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); + + monitor.subTask(NLS.bind(Messages.ProjectConfigurationManager_task_executing_archetype, archetype.getGroupId(), archetype.getArtifactId())); + if(location == null) { + // if the project should be created in the workspace, figure out the path + location = workspaceRoot.getLocation(); + } + + try { + + + + Artifact artifact = resolveArchetype(archetype, monitor); + + ArchetypeGenerationRequest request = new ArchetypeGenerationRequest() // + .setTransferListener(maven.createTransferListener(monitor)) // + .setArchetypeGroupId(artifact.getGroupId()) // + .setArchetypeArtifactId(artifact.getArtifactId()) // + .setArchetypeVersion(artifact.getVersion()) // + .setArchetypeRepository(archetype.getRepository()) // + .setGroupId(groupId) // + .setArtifactId(artifactId) // + .setVersion(version) // + .setPackage(javaPackage) // the model does not have a package field + .setLocalRepository(maven.getLocalRepository()) // + .setRemoteArtifactRepositories(maven.getArtifactRepositories(true)) + .setProperties(properties).setOutputDirectory(location.toPortableString()); + + MavenSession session = maven.createSession(maven.createExecutionRequest(monitor), null); + + MavenSession oldSession = MavenPlugin.getDefault().setSession(session); + + ArchetypeGenerationResult result; + try { + result = getArchetyper().generateProjectFromArchetype(request); + } finally { + MavenPlugin.getDefault().setSession(oldSession); + } + + Exception cause = result.getCause(); + if(cause != null) { + String msg = NLS.bind(Messages.ProjectConfigurationManager_error_unable_archetype, archetype.toString()); + MavenLogger.log(msg, cause); + throw new CoreException(new Status(IStatus.ERROR, IMavenConstants.PLUGIN_ID, -1, msg, cause)); + } + monitor.worked(1); + + // XXX Archetyper don't allow to specify project folder + String projectFolder = location.append(artifactId).toFile().getAbsolutePath(); + + LocalProjectScanner scanner = new LocalProjectScanner(workspaceRoot.getLocation().toFile(), // + projectFolder, true, mavenModelManager, console); + scanner.run(monitor); + + Set<MavenProjectInfo> projectSet = collectProjects(scanner.getProjects()); + + importProjects(projectSet, configuration, monitor); + + monitor.worked(1); + } catch (CoreException e) { + throw e; + } catch (InterruptedException e) { + throw new CoreException(Status.CANCEL_STATUS); + } catch (Exception ex) { + throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.m2e", Messages.ProjectConfigurationManager_error_failed, ex)); //$NON-NLS-1$ + } + } + + /** + * Apparently, Archetype#generateProjectFromArchetype 2.0-alpha-4 does not attempt to resolve archetype + * from configured remote repositories. To compensate, we populate local repo with archetype pom/jar. + */ + private Artifact resolveArchetype(Archetype a, IProgressMonitor monitor) throws CoreException { + ArrayList<ArtifactRepository> repos = new ArrayList<ArtifactRepository>(); + repos.addAll(maven.getArtifactRepositories()); // see org.apache.maven.archetype.downloader.DefaultDownloader#download + + //MNGECLIPSE-1399 use archetype repository too, not just the default ones + String artifactRemoteRepository = a.getRepository(); + + try { + + if (StringUtils.isBlank(artifactRemoteRepository)){ + + IMavenConfiguration mavenConfiguration = MavenPlugin.getDefault().getMavenConfiguration(); + if (!mavenConfiguration.isOffline()){ + //Try to find the repository from remote catalog if needed + final ArchetypeManager archetypeManager = MavenPlugin.getDefault().getArchetypeManager(); + RemoteCatalogFactory factory = archetypeManager.findParentCatalogFactory(a, RemoteCatalogFactory.class); + if (factory != null) { + //Grab the computed remote repository url + artifactRemoteRepository = factory.getRepositoryUrl(); + a.setRepository(artifactRemoteRepository);//Hopefully will prevent further lookups for the same archetype + } + } + } + + if (StringUtils.isNotBlank(artifactRemoteRepository)) { + ArtifactRepository archetypeRepository = maven.createArtifactRepository("archetype", a.getRepository().trim()); //$NON-NLS-1$ + repos.add(0,archetypeRepository);//If the archetype doesn't exist locally, this will be the first remote repo to be searched. + } + + maven.resolve(a.getGroupId(), a.getArtifactId(),a.getVersion(), "pom", null, repos, monitor); //$NON-NLS-1$ + return maven.resolve(a.getGroupId(), a.getArtifactId(),a.getVersion(), "jar", null, repos, monitor); //$NON-NLS-1$ + } catch (CoreException e) { + StringBuilder sb = new StringBuilder(); + sb.append(Messages.ProjectConfigurationManager_error_resolve).append(a.getGroupId()).append(':').append(a.getArtifactId()).append(':').append(a.getVersion()); + sb.append(Messages.ProjectConfigurationManager_error_resolve2); + throw new CoreException(new Status(IStatus.ERROR, IMavenConstants.PLUGIN_ID, -1, sb.toString(), e)); + } + } + + private org.apache.maven.archetype.Archetype getArchetyper() { + return MavenPlugin.getDefault().getArchetype(); + } + + public Set<MavenProjectInfo> collectProjects(Collection<MavenProjectInfo> projects) { + + // TODO what does this do? + return new LinkedHashSet<MavenProjectInfo>() { + private static final long serialVersionUID = 1L; + + public Set<MavenProjectInfo> collectProjects(Collection<MavenProjectInfo> projects) { + for(MavenProjectInfo projectInfo : projects) { + console.logMessage("Collecting project info " + projectInfo); + add(projectInfo); + collectProjects(projectInfo.getProjects()); + } + return this; + } + }.collectProjects(projects); + } + + public ISchedulingRule getRule() { + return ResourcesPlugin.getWorkspace().getRuleFactory().buildRule(); + } + + private IProject create(MavenProjectInfo projectInfo, ProjectImportConfiguration configuration, IProgressMonitor monitor) throws CoreException { + IWorkspace workspace = ResourcesPlugin.getWorkspace(); + IWorkspaceRoot root = workspace.getRoot(); + + File pomFile = projectInfo.getPomFile(); + Model model = projectInfo.getModel(); + if(model == null) { + model = maven.readModel(pomFile); + projectInfo.setModel(model); + } + + String projectName = configuration.getProjectName(model); + + File projectDir = pomFile.getParentFile(); + String projectParent = projectDir.getParentFile().getAbsolutePath(); + + if (projectInfo.getBasedirRename() == MavenProjectInfo.RENAME_REQUIRED) { + File newProject = new File(projectDir.getParent(), projectName); + if(!projectDir.equals(newProject)) { + boolean renamed = projectDir.renameTo(newProject); + if(!renamed) { + StringBuilder msg = new StringBuilder(); + msg.append(NLS.bind(Messages.ProjectConfigurationManager_error_rename, projectDir.getAbsolutePath())).append('.'); + if (newProject.exists()) { + msg.append(NLS.bind(Messages.ProjectConfigurationManager_error_targetDir, newProject.getAbsolutePath())); + } + throw new CoreException(new Status(IStatus.ERROR, IMavenConstants.PLUGIN_ID, -1, msg.toString(), null)); + } + projectInfo.setPomFile(getCanonicalPomFile(newProject)); + projectDir = newProject; + } + } else { + if(projectParent.equals(root.getLocation().toFile().getAbsolutePath())) { + // immediately under workspace root, project name must match filesystem directory name + projectName = projectDir.getName(); + } + } + + monitor.subTask(NLS.bind(Messages.ProjectConfigurationManager_task_importing2, projectName)); + + IProject project = root.getProject(projectName); + if(project.exists()) { + console.logError("Project " + projectName + " already exists"); + return null; + } + + if(projectDir.equals(root.getLocation().toFile())) { + console.logError("Can't create project " + projectName + " at Workspace folder"); + return null; + } + + if(projectParent.equals(root.getLocation().toFile().getAbsolutePath())) { + project.create(monitor); + } else { + IProjectDescription description = workspace.newProjectDescription(projectName); + description.setLocation(new Path(projectDir.getAbsolutePath())); + project.create(description, monitor); + } + + if(!project.isOpen()) { + project.open(monitor); + } + + ResolverConfiguration resolverConfiguration = configuration.getResolverConfiguration(); + enableBasicMavenNature(project, resolverConfiguration, monitor); + + return project; + } + + private File getCanonicalPomFile(File projectDir) throws CoreException { + try { + return new File(projectDir.getCanonicalFile(), IMavenConstants.POM_FILE_NAME); + } catch(IOException ex) { + throw new CoreException(new Status(IStatus.ERROR, IMavenConstants.PLUGIN_ID, -1, // + NLS.bind(Messages.ProjectConfigurationManager_0, projectDir.getAbsolutePath()), null)); + } + } + + public void mavenProjectChanged(MavenProjectChangedEvent[] events, IProgressMonitor monitor) { + for(MavenProjectChangedEvent event : events) { + try { + ILifecycleMapping lifecycleMapping = getLifecycleMapping(event.getMavenProject(), monitor); + if(lifecycleMapping != null) { + for(AbstractProjectConfigurator configurator : lifecycleMapping.getProjectConfigurators(event.getMavenProject(), monitor)) { + //MNGECLIPSE-2004 : only send the relevant event to the configurator + configurator.mavenProjectChanged(event, monitor); + } + } + } catch (CoreException e) { + MavenLogger.log(e); + } + } + } + + public ILifecycleMapping getLifecycleMapping(IMavenProjectFacade projectFacade, IProgressMonitor monitor) throws CoreException { + if (projectFacade==null) { + return null; + } + + return projectFacade.getLifecycleMapping(monitor); + } + + public ILifecycleMapping getDefaultLifecycleMapping(IMavenProjectFacade projectFacade, IProgressMonitor monitor) + throws CoreException { + if(projectFacade == null) { + return null; + } + + return projectFacade.getLifecycleMapping(monitor); + } +} |