path: root/org.eclipse.m2e.importer/src/org/eclipse/m2e/importer/internal/MavenProjectConfigurator.java

/*******************************************************************************
 * Copyright (c) 2014-2015 Red Hat 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
 *******************************************************************************/
package org.eclipse.m2e.importer.internal;

import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.m2e.core.MavenPlugin;
import org.eclipse.m2e.core.internal.IMavenConstants;
import org.eclipse.m2e.core.internal.jobs.IBackgroundProcessingQueue;
import org.eclipse.m2e.core.internal.lifecyclemapping.discovery.LifecycleMappingDiscoveryRequest;
import org.eclipse.m2e.core.internal.project.ProjectConfigurationManager;
import org.eclipse.m2e.core.project.IProjectConfigurationManager;
import org.eclipse.m2e.core.project.LocalProjectScanner;
import org.eclipse.m2e.core.project.MavenProjectInfo;
import org.eclipse.m2e.core.project.MavenUpdateRequest;
import org.eclipse.m2e.core.project.ResolverConfiguration;
import org.eclipse.m2e.core.ui.internal.wizards.LifecycleMappingDiscoveryHelper;
import org.eclipse.m2e.core.ui.internal.wizards.MappingDiscoveryJob;
import org.eclipse.ui.internal.wizards.datatransfer.SmartImportJob;
import org.eclipse.ui.wizards.datatransfer.ProjectConfigurator;

public class MavenProjectConfigurator implements ProjectConfigurator {

    public static final String UPDATE_MAVEN_CONFIGURATION_JOB_NAME = "Update Maven projects configuration";

    private static class CumulativeMappingDiscoveryJob extends MappingDiscoveryJob {
        private static CumulativeMappingDiscoveryJob INSTANCE;
        private Set<IProject> toProcess;
        private boolean started;

        public synchronized static CumulativeMappingDiscoveryJob getInstance() {
            if (INSTANCE == null) {
                INSTANCE = new CumulativeMappingDiscoveryJob();
            }
            return INSTANCE;
        }

        private CumulativeMappingDiscoveryJob() {
            super(null);
            this.toProcess = Collections.synchronizedSet(new HashSet<IProject>());
        }
        
        public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
            try {
                // This makes job execution wait until the main Import job is completed
                // So the mapping discovery happens as a next step, after projects are imported in workspace
                getJobManager().join(SmartImportJob.class, monitor);
            } catch (InterruptedException ex) {
                throw new CoreException(new Status(IStatus.WARNING,
                        Activator.getDefault().getBundle().getSymbolicName(), ex.getMessage(), ex));
            }
            synchronized (this.toProcess) {
                this.started = true;
            }
            // Detect and resolve Lifecycle Mapping issues
            try {
                LifecycleMappingDiscoveryRequest discoveryRequest = LifecycleMappingDiscoveryHelper
                        .createLifecycleMappingDiscoveryRequest(toProcess, monitor);
                if (discoveryRequest.isMappingComplete()) {
                    return Status.OK_STATUS;
                }
                // Some errors were detected
                discoverProposals(discoveryRequest, monitor);
                openProposalWizard(toProcess, discoveryRequest);
            } finally {
                this.toProcess.clear();
                this.started = false;
            }
            return Status.OK_STATUS;
        }

        public void addProjects(Collection<IProject> projects) {
            synchronized (this.toProcess) {
                if (this.started) {
                    throw new IllegalStateException("Cannot add projects when processing is started");
                }
                if (projects != null) {
                    this.toProcess.addAll(projects);
                }
            }
        }

    }

    /**
     * This singleton job will loop running on the background to update
     * configuration of Maven projects as they're imported.
     * 
     * @author mistria
     *
     */
    public static class UpdateMavenConfigurationJob extends Job implements IBackgroundProcessingQueue {

        private static UpdateMavenConfigurationJob INSTANCE;
        private Set<IProject> toProcess;

        public synchronized static UpdateMavenConfigurationJob getInstance() {
            if (INSTANCE == null) {
                INSTANCE = new UpdateMavenConfigurationJob();
            }
            return INSTANCE;
        }

        private UpdateMavenConfigurationJob() {
            super(UPDATE_MAVEN_CONFIGURATION_JOB_NAME);
            this.toProcess = Collections.synchronizedSet(new HashSet<IProject>());
            this.setUser(true);
        }

        /**
         * Rather than scheduling this job another time, requestors simply add
         * to ask for being processed here. The job lifecycle will take care of
         * processing it as best.
         * 
         * @param project
         */
        public void addProjectToProcess(IProject project) {
            synchronized (this.toProcess) {
                toProcess.add(project);
            }
        }

        @Override
        public IStatus run(IProgressMonitor monitor) {
            Set<IProject> toProcessNow = new HashSet<IProject>();
            while (!monitor.isCanceled()) {
                synchronized (this.toProcess) {
                    if (this.toProcess.isEmpty()) {
                        CumulativeMappingDiscoveryJob.getInstance().schedule();
                        return Status.OK_STATUS;
                    } else {
                        toProcessNow.addAll(this.toProcess);
                        this.toProcess.removeAll(toProcessNow);
                    }
                }
                if (!toProcessNow.isEmpty()) {
                    CumulativeMappingDiscoveryJob.getInstance().addProjects(toProcessNow);
                    ProjectConfigurationManager configurationManager = (ProjectConfigurationManager) MavenPlugin
                            .getProjectConfigurationManager();
                    MavenUpdateRequest request = new MavenUpdateRequest(
                            toProcessNow.toArray(new IProject[toProcessNow.size()]), false, false);
                    Map<String, IStatus> updateStatus = configurationManager.updateProjectConfiguration(request, true,
                            false, false, monitor);
                }
            }
            return new Status(IStatus.CANCEL, Activator.getDefault().getBundle().getSymbolicName(),
                    "Cancelled by user");
        }

        @Override
        public boolean isEmpty() {
            return this.toProcess.isEmpty();
        }

    }

    @Override
    public Set<File> findConfigurableLocations(File root, IProgressMonitor monitor) {
        LocalProjectScanner scanner = new LocalProjectScanner(
                ResourcesPlugin.getWorkspace().getRoot().getLocation().toFile(), root.getAbsolutePath(), false,
                MavenPlugin.getMavenModelManager());
        try {
            scanner.run(monitor);
        } catch (Exception ex) {
            Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage(), ex));
            return null;
        }
        Queue<MavenProjectInfo> projects = new LinkedList<MavenProjectInfo>();
        projects.addAll(scanner.getProjects());
        HashSet<File> res = new HashSet<File>();
        while (!projects.isEmpty()) {
            MavenProjectInfo projectInfo = projects.poll();
            res.add(projectInfo.getPomFile().getParentFile());
            projects.addAll(projectInfo.getProjects());
        }
        return res;
    }
    
    // TODO Uncomment @Override when this method API is exposed in ProjectConfigurator
    // @Override
    public void removeDirtyDirectories(Map<File, List<ProjectConfigurator>> proposals) {
        Set<File> toRemove = new HashSet<File>();
        for (File directory : proposals.keySet()) {
            String path = directory.getAbsolutePath();
            if (!path.endsWith(File.separator)) {
                path += File.separator;
            }
            int index = path.indexOf(File.separator + "target" + File.separator); //$NON-NLS-1$
            if (index >= 0) {
                File potentialPomFile = new File(path.substring(0, index), "pom.xml"); //$NON-NLS-1$
                if (potentialPomFile.isFile()) {
                    toRemove.add(directory);
                }
            }
        }
        for (File directory : toRemove) {
            proposals.remove(directory);
        }
    }

    @Override
    public boolean canConfigure(IProject project, Set<IPath> ignoredPaths, IProgressMonitor monitor) {
        return shouldBeAnEclipseProject(project, monitor);
    }

    // TODO this method is going to be removed from API.
    // When done, also remove this method implementation.
    public IWizard getConfigurationWizard() {
        // no need for a wizard, will just set up the m2e nature
        return null;
    }

    @Override
    public void configure(final IProject project, Set<IPath> excludedDirectories, final IProgressMonitor monitor) {
        // copied from
        // org.eclipse.m2e.core.ui.internal.actions.EnableNatureAction

        final ResolverConfiguration configuration = new ResolverConfiguration();
        configuration.setResolveWorkspaceProjects(true);
        final IProjectConfigurationManager configurationManager = MavenPlugin.getProjectConfigurationManager();
        try {
            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);
            }
            UpdateMavenConfigurationJob.getInstance().addProjectToProcess(project);
            if (UpdateMavenConfigurationJob.getInstance().getState() == Job.NONE) {
                UpdateMavenConfigurationJob.getInstance().schedule();
            }
        } catch (Exception ex) {
            Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage(), ex));
        }
    }

    @Override
    public boolean shouldBeAnEclipseProject(IContainer container, IProgressMonitor monitor) {
        IFile pomFile = container.getFile(new Path(IMavenConstants.POM_FILE_NAME));
        return pomFile.exists();
        // debated on m2e-dev:
        // https://dev.eclipse.org/mhonarc/lists/m2e-dev/msg01852.html
        // if (!pomFile.exists()) {
        // return false;
        // }
        // try {
        // Model pomModel =
        // MavenPlugin.getMavenModelManager().readMavenModel(pomFile);
        // return !pomModel.getPackaging().equals("pom"); // TODO find symbol
        // for "pom"
        // } catch (CoreException ex) {
        // Activator.log(IStatus.ERROR, "Could not parse pom file " +
        // pomFile.getLocation(), ex);
        // return false;
        // }
    }

    // Prepare for compatibility with M7
    // @Override
    public Set<IFolder> getFoldersToIgnore(IProject project, IProgressMonitor monitor) {
        Set<IFolder> res = new HashSet<IFolder>();
        // TODO: get these values from pom/project config
        res.add(project.getFolder("src"));
        res.add(project.getFolder("target"));
        return res;
    }

    // Prepare for compatibility with M7
    // @Override
    public Set<IFolder> getDirectoriesToIgnore(IProject project, IProgressMonitor monitor) {
        return getFoldersToIgnore(project, monitor);
    }

}