path: root/sandbox/rfeng/eclipse-workspace/src/main/java/org/apache/tuscany/eclipse/workspace/WorkspaceConfigurator.java

/*
 * 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.tuscany.eclipse.workspace;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;

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.IncrementalProjectBuilder;
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.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper;
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.LoadTargetDefinitionJob;
import org.xml.sax.SAXException;

@SuppressWarnings("restriction")
public class WorkspaceConfigurator implements IApplication {
    private static final String SOURCE_ROOT = "source.root";
    private static final String TARGET_DEFINITION = "target.definition";
    private static final String MAVEN_LOCAL_REPO = "maven.repo";
    private static final String M2_REPO = "M2_REPO";

    private IWorkspace workspace;
    private final Object lock = new Object();

    public Object start(final IApplicationContext appcontext) throws Exception {
        final String[] args = (String[])appcontext.getArguments().get(IApplicationContext.APPLICATION_ARGS);
        configure(args);
        return EXIT_OK;
    }

    private void configure(final String[] args) throws JavaModelException, InterruptedException, Exception,
        CoreException, FileNotFoundException, ParserConfigurationException, SAXException, IOException {
        print("Starting to configure the workspace...");
        IProgressMonitor monitor = createMonitor();

        // Configure JDT
        configureJDT();

        // Set M2_REPO classpath variable
        configureMavenClassPathVariable(args, monitor);

        // Schedule a job to set target platform
        setTargetPlatform(args, monitor);

        // Import/refresh projects
        configureWorkspace(args, monitor);

        // Start a clean/full build
        buildWorkspace(monitor);

        // Save the workspace
        workspace.save(true, monitor);
    }

    private void setTargetPlatform(String args[], IProgressMonitor monitor) throws Exception {
        String targetFile = getOptionValue(args, TARGET_DEFINITION);
        if (targetFile == null) {
            return;
        }
        File tf = new File(targetFile).getAbsoluteFile();
        print("Setting target platform: " + tf);
        ITargetPlatformService tps =
            (ITargetPlatformService)PDECore.getDefault().acquireService(ITargetPlatformService.class.getName());
        ITargetHandle th = tps.getTarget(tf.toURI());
        FileInputStream is = new FileInputStream(tf);
        try {
            TargetDefinitionPersistenceHelper.initFromXML(th.getTargetDefinition(), is);
        } finally {
            is.close();
        }
        LoadTargetDefinitionJob job = new LoadTargetDefinitionJob(th.getTargetDefinition());
        Job.getJobManager().cancel("LoadTargetDefinitionJob");
        job.setUser(true);
        job.addJobChangeListener(new IJobChangeListener() {

            @Override
            public void sleeping(IJobChangeEvent event) {
            }

            @Override
            public void scheduled(IJobChangeEvent event) {
            }

            @Override
            public void running(IJobChangeEvent event) {
            }

            @Override
            public void done(IJobChangeEvent event) {
                print("Target platform is now configured. (" + event.getResult() + ")");
                synchronized (lock) {
                    lock.notifyAll();
                }
            }

            @Override
            public void awake(IJobChangeEvent event) {
            }

            @Override
            public void aboutToRun(IJobChangeEvent event) {
            }
        });
        job.schedule();
        // Wait for the target platform to be set
        synchronized (lock) {
            lock.wait(60000);
        }

    }

    private IProgressMonitor createMonitor() {
        return new NullProgressMonitor() {

            @Override
            public void beginTask(String name, int totalWork) {
            }

            @Override
            public void done() {
                // System.out.println();
            }

            @Override
            public void worked(int work) {
                // System.out.print(".");
            }
        };
    }

    private IPath configureMavenClassPathVariable(String args[], IProgressMonitor monitor) throws JavaModelException {
        IPath var = JavaCore.getClasspathVariable(M2_REPO);
        if (var == null) {
            String localRepo = getOptionValue(args, MAVEN_LOCAL_REPO);
            if (localRepo == null) {
                String home = System.getProperty("user.home");
                localRepo = home + File.separator + ".m2" + File.separator + "repository";
            }
            File repo = new File(localRepo);
            IPath path = new Path(repo.getAbsolutePath());
            JavaCore.setClasspathVariable(M2_REPO, path, monitor);
            return path;
        }
        return var;
    }

    private void configureWorkspace(final String[] args, IProgressMonitor monitor) throws Exception, CoreException {
        this.workspace = ResourcesPlugin.getWorkspace();

        String sourceRootArg = getOptionValue(args, SOURCE_ROOT);
        File sourceRoot = null;
        if (sourceRootArg != null) {
            sourceRoot = new File(sourceRootArg);
        }

        configureProjects(sourceRoot, monitor);

    }

    private String getOptionValue(final String[] args, String option) {
        String value = null;
        if (args != null) {
            List<String> argList = Arrays.asList(args);
            int index = argList.indexOf("-" + option);
            if (index != -1 && argList.size() - 1 >= index + 1) {
                value = argList.get(index + 1);
            }
        }
        return value;
    }

    public void stop() {
        this.workspace = null;
    }

    private void configureProjects(File sourceRoot, final IProgressMonitor monitor) throws Exception {
        IWorkspaceRoot workspaceRoot = workspace.getRoot();

        if (sourceRoot != null) {
            print("Scanning " + sourceRoot);
            loadProjects(sourceRoot, monitor);
        }

        for (IProject p : workspaceRoot.getProjects()) {
            print("Refreshing project: " + p.getName());
            if (!p.isOpen()) {
                // Open the project
                p.open(monitor);
            } else {
                // Refresh the project
                p.refreshLocal(IResource.DEPTH_INFINITE, monitor);
            }
            if (p.getFile(".project") == null) {
                print("Deleting project: " + p.getName());
                p.delete(false, true, monitor);
            }
        }

        // If we set .svn to private member, the svn plugin will not bind the project
        /*
        workspaceRoot.accept(new IResourceVisitor() {

            public boolean visit(IResource res) throws CoreException {
                if (res.getName().equals(".svn")) {
                    if (!res.isTeamPrivateMember()) {
                        res.setTeamPrivateMember(true);
                    }
                    return false;
                }
                return true;
            }
        });
        */

    }

    @SuppressWarnings("unchecked")
    private void configureJDT() {
        Hashtable<Object, Object> options = JavaCore.getOptions();
        options.put(JavaCore.CORE_CIRCULAR_CLASSPATH, JavaCore.ERROR);
        options.put(JavaCore.CORE_INCOMPLETE_CLASSPATH, JavaCore.WARNING);
        JavaCore.setOptions(options);

        IVMInstall vminstall = JavaRuntime.getDefaultVMInstall();
        if (!vminstall.getName().equals("Default JRE")) {
            vminstall.setName("Default JRE");
        }
    }

    private void loadProjects(File sourceRoot, final IProgressMonitor monitor) throws CoreException {
        if (sourceRoot == null) {
            return;
        }
        if (sourceRoot.isDirectory()) {
            File dotProject = new File(sourceRoot, ".project");
            if (dotProject.exists() && dotProject.isFile()) {
                IPath path = new Path(dotProject.getAbsolutePath());
                IProjectDescription project = workspace.loadProjectDescription(path);
                IProject p = workspace.getRoot().getProject(project.getName());
                if (!p.exists()) {
                    print("Importing project: " + project.getName());
                    p.create(project, monitor);
                }
            }
        } else {
            return;
        }

        File[] dirs = sourceRoot.listFiles();
        if (dirs == null) {
            return;
        }

        for (File dir : dirs) {
            if (dir.isDirectory() && !dir.getName().startsWith(".")) {
                loadProjects(dir, monitor);
            }
        }
    }

    private void buildWorkspace(IProgressMonitor monitor) throws Exception {
        print("Running a clean/full build...");
        workspace.build(IncrementalProjectBuilder.CLEAN_BUILD, monitor);
        workspace.build(IncrementalProjectBuilder.FULL_BUILD, monitor);

        reportErrors();
    }

    private void reportErrors() throws CoreException {
        int errorCount = 0;
        print();
        IProject[] projects = workspace.getRoot().getProjects();
        HashMap<String, List<IMarker>> errors = new HashMap<String, List<IMarker>>();
        for (IProject p : projects) {
            IMarker[] markers = p.findMarkers(null, true, IResource.DEPTH_INFINITE);
            for (int m = 0; m < markers.length; m++) {
                IMarker marker = markers[m];
                int severity = marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
                if (severity == IMarker.SEVERITY_ERROR) {
                    List<IMarker> list = errors.get(p.getName());
                    if (list == null) {
                        list = new ArrayList<IMarker>();
                        errors.put(p.getName(), list);
                    }
                    list.add(marker);
                    reportError(marker);
                    errorCount++;
                }
            }
        }

        Iterator<String> it = errors.keySet().iterator();
        while (it.hasNext()) {
            String project = it.next();
            List<IMarker> list = errors.get(project);
            print("Project " + project + " has " + list.size() + " errors.");
        }
        print();

        if (errorCount > 0) {
            print("The build is completed with " + errorCount + " errors.");
        } else {
            print("The build is completed successfully.");
        }
        print();
    }

    private void reportError(IMarker marker) throws CoreException {
        print("Error: " + marker.getResource()
            + ":"
            + marker.getAttribute(IMarker.LINE_NUMBER, 0)
            + ": "
            + marker.getAttribute(IMarker.MESSAGE));
    }

    private void print(Object... msgs) {
        for (Object msg : msgs) {
            System.out.println(msg);
        }
    }
}