org.apache.ivyde.eclipse/src/java/org/apache/ivyde/internal/eclipse/IvyPlugin.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.ivyde.internal.eclipse;

import java.io.File;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.ivy.Ivy;
import org.apache.ivyde.common.ivyfile.IvyFileResourceListener;
import org.apache.ivyde.eclipse.cp.IvyClasspathContainer;
import org.apache.ivyde.eclipse.cp.IvyClasspathContainerHelper;
import org.apache.ivyde.internal.eclipse.cpcontainer.IvyAttachementManager;
import org.apache.ivyde.internal.eclipse.cpcontainer.IvyClasspathContainerImpl;
import org.apache.ivyde.internal.eclipse.cpcontainer.IvyClasspathContainerSerializer;
import org.apache.ivyde.internal.eclipse.resolve.IvyResolveJob;
import org.apache.ivyde.internal.eclipse.retrieve.RetrieveSetupManager;
import org.apache.ivyde.internal.eclipse.ui.console.IvyConsole;
import org.apache.ivyde.internal.eclipse.ui.console.IvyConsoleFactory;
import org.apache.ivyde.internal.eclipse.ui.editors.xml.ColorManager;
import org.apache.ivyde.internal.eclipse.ui.preferences.IvyDEPreferenceStoreHelper;
import org.apache.ivyde.internal.eclipse.ui.preferences.PreferenceConstants;
import org.apache.ivyde.internal.eclipse.workspaceresolver.WorkspaceResourceChangeListener;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

/**
 * The main plugin class to be used in the desktop.
 */
public class IvyPlugin extends AbstractUIPlugin {

    private static final Pattern IVY_VERSION_PATTERN = Pattern
            .compile("([0-9]+)\\.([0-9]+)\\.([0-9]+).*");

    /** The ID of IvyDE plugin */
    public static final String ID = "org.apache.ivyde.eclipse";

    /** The ID of IvyDE problem markers */
    public static final String MARKER_ID = ID + ".marker";

    // The shared instance.
    private volatile static IvyPlugin plugin;

    // Resource bundle.
    private ResourceBundle resourceBundle;

    private IvyConsole console;

    private IvyDEPreferenceStoreHelper prefStoreHelper;

    private BundleContext bundleContext;

    private ColorManager colorManager;

    private IvyResolveJob ivyResolveJob;

    private RetrieveSetupManager retrieveSetupManager;

    private WorkspaceResourceChangeListener workspaceListener;

    private IvyFileResourceListener ivyFileListener;

    private IPropertyChangeListener propertyListener;

    private IvyMarkerManager ivyMarkerManager;

    private boolean osgiAvailable;

    private boolean osgiClasspathAvailable;

    private IvyClasspathContainerSerializer ivyCpcSerializer;

    private IvyAttachementManager ivyAttachementManager;

    private int ivyVersionMajor = 0;

    private int ivyVersionMinor = 0;

    private int ivyVersionPatch = 0;

    /**
     * The constructor.
     */
    public IvyPlugin() {
        super();
        plugin = this;
    }

    /**
     * This method is called upon plug-in activation
     */
    public void start(BundleContext context) throws Exception {
        super.start(context);
        this.bundleContext = context;
        logInfo("starting IvyDE plugin");

        Matcher matcher = IVY_VERSION_PATTERN.matcher(Ivy.getIvyVersion());
        if (matcher.matches()) {
            ivyVersionMajor = Integer.parseInt(matcher.group(1));
            ivyVersionMinor = Integer.parseInt(matcher.group(2));
            ivyVersionPatch = Integer.parseInt(matcher.group(3));
        }

        ivyResolveJob = new IvyResolveJob();

        retrieveSetupManager = new RetrieveSetupManager();

        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        workspace.addSaveParticipant(this, retrieveSetupManager);

        colorManager = new ColorManager();
        Display.getDefault().asyncExec(new Runnable() {
            public void run() {
                colorManager.refreshFromStore(getPreferenceStore());
            }
        });

        prefStoreHelper = new IvyDEPreferenceStoreHelper(getPreferenceStore());

        propertyListener = new IPropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent event) {
                try {
                    if (PreferenceConstants.ALL.contains(event.getProperty())) {
                        prefStoreChanged();
                    }
                } catch (JavaModelException e) {
                    MessageDialog.openError(IvyPlugin.getDefault().getWorkbench()
                            .getActiveWorkbenchWindow().getShell(),
                        "Unable to trigger the update the IvyDE classpath containers",
                        e.getMessage());
                }
            }
        };
        getPreferenceStore().addPropertyChangeListener(propertyListener);

        Display.getDefault().asyncExec(new Runnable() {
            public void run() {
                try {
                    console = new IvyConsole();
                    if (prefStoreHelper.isOpenIvyConsoleOnStartup()) {
                        IvyConsoleFactory.showConsole();
                    }
                } catch (RuntimeException e) {
                    // Don't let the console bring down the IvyDE UI
                    logError("Errors occurred starting the Ivy console", e);
                }
            }
        });

        // Listen for project open/close events to auto-update inter-project dependencies
        workspaceListener = new WorkspaceResourceChangeListener();
        workspace.addResourceChangeListener(workspaceListener);
        ivyFileListener = new IvyFileResourceListener();
        workspace.addResourceChangeListener(ivyFileListener, IResourceChangeEvent.PRE_BUILD);

        ivyMarkerManager = new IvyMarkerManager();

        File stateLocation = getStateLocation().toFile();
        ivyAttachementManager = new IvyAttachementManager(new File(stateLocation,
                "attachements.properties"));
        File containersStateDir = new File(stateLocation, "cpstates");
        if (!containersStateDir.exists()) {
            containersStateDir.mkdirs();
        }
        ivyCpcSerializer = new IvyClasspathContainerSerializer(containersStateDir,
                ivyAttachementManager);

        try {
            Class.forName("org.apache.ivy.osgi.core.ManifestParser");
            osgiAvailable = true;
            try {
                Class.forName("org.apache.ivy.osgi.core.BundleInfo").getDeclaredMethod(
                    "getClasspath");
                osgiClasspathAvailable = true;
            } catch (Exception e) {
                osgiClasspathAvailable = false;
            }
        } catch (Exception e) {
            osgiAvailable = false;
            osgiClasspathAvailable = false;
        }

        logInfo("IvyDE plugin started");
    }

    /**
     * This method is called when the plug-in is stopped
     */
    public void stop(BundleContext context) throws Exception {
        super.stop(context);
        ivyCpcSerializer = null;
        ivyAttachementManager = null;
        resourceBundle = null;
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        workspace.removeSaveParticipant(this);
        colorManager = null;
        ivyMarkerManager = null;
        ivyResolveJob = null;
        retrieveSetupManager = null;
        workspace.removeResourceChangeListener(workspaceListener);
        workspaceListener = null;
        workspace.removeResourceChangeListener(ivyFileListener);
        ivyFileListener = null;

        getPreferenceStore().removePropertyChangeListener(propertyListener);
        propertyListener = null;

        if (console != null) {
            console.destroy();
        }
        plugin = null;
    }

    void prefStoreChanged() throws JavaModelException {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IJavaModel javaModel = JavaCore.create(workspace.getRoot());
        IJavaProject[] projects = javaModel.getJavaProjects();
        for (int i = 0; i < projects.length; i++) {
            List<IvyClasspathContainer> containers = IvyClasspathContainerHelper
                    .getContainers(projects[i]);
            Iterator<IvyClasspathContainer> itContainers = containers.iterator();
            while (itContainers.hasNext()) {
                IvyClasspathContainerImpl ivycp = (IvyClasspathContainerImpl) itContainers.next();
                if (!ivycp.getConf().isSettingsProjectSpecific()) {
                    ivycp.launchResolve(false, null);
                }
            }
        }
    }

    /**
     * Convenience method for logging statuses to the plugin log
     * 
     * @param status
     *            the status to log
     */
    public static void log(IStatus status) {
        getDefault().getLog().log(status);
        switch (status.getCode()) {
            case IStatus.ERROR:
                IvyDEMessage.error(status.getMessage(), status.getException());
                break;
            case IStatus.CANCEL:
            case IStatus.WARNING:
                IvyDEMessage.warn(status.getMessage(), status.getException());
                break;
            case IStatus.OK:
            case IStatus.INFO:
                IvyDEMessage.info(status.getMessage(), status.getException());
                break;
        }
    }

    public static void log(CoreException e) {
        log(e.getStatus().getSeverity(), "IvyDE internal error", e);
    }

    /**
     * Log the given exception along with the provided message and severity indicator
     */
    public static void log(int severity, String message, Throwable e) {
        log(new Status(severity, ID, 0, message, e));
    }

    public static void logInfo(String message) {
        log(new Status(IStatus.INFO, ID, 0, message, null));
    }

    public static void logWarn(String message) {
        logWarn(message, null);
    }

    public static void logWarn(String message, Throwable e) {
        log(new Status(IStatus.WARNING, ID, 0, message, e));
    }

    public static void logError(String message) {
        logError(message, null);
    }

    public static void logError(String message, Throwable e) {
        log(new Status(IStatus.ERROR, ID, 0, message, e));
    }

    /**
     * Returns the shared instance.
     * 
     * @return the plugin instance
     */
    public static IvyPlugin getDefault() {
        return plugin;
    }

    public boolean isOsgiAvailable() {
        return osgiAvailable;
    }

    public boolean isOsgiClasspathAvailable() {
        return osgiClasspathAvailable;
    }

    /**
     * Returns the active workbench shell
     * 
     * @return the active workbench shell
     */
    public static Shell getActiveWorkbenchShell() {
        IWorkbenchWindow workBenchWindow = getActiveWorkbenchWindow();
        if (workBenchWindow == null) {
            return null;
        }
        return workBenchWindow.getShell();
    }

    /**
     * Returns the active workbench page or <code>null</code> if none.
     * 
     * @return the active workbench page
     */
    public static IWorkbenchPage getActivePage() {
        IWorkbenchWindow window = getActiveWorkbenchWindow();
        if (window != null) {
            return window.getActivePage();
        }
        return null;
    }

    /**
     * Returns the active workbench window
     * 
     * @return the active workbench window
     */
    public static IWorkbenchWindow getActiveWorkbenchWindow() {
        if (getDefault() == null) {
            return null;
        }
        IWorkbench workBench = getDefault().getWorkbench();
        if (workBench == null) {
            return null;
        }
        return workBench.getActiveWorkbenchWindow();
    }

    /**
     * Returns the string from the plugin's resource bundle, or 'key' if not found.
     */
    public static String getResourceString(String key) {
        ResourceBundle bundle = IvyPlugin.getDefault().getResourceBundle();
        try {
            return (bundle != null) ? bundle.getString(key) : key;
        } catch (MissingResourceException e) {
            return key;
        }
    }

    /**
     * Utility class that tries to adapt a non null object to the specified type
     * 
     * @param object
     *            the object to adapt
     * @param type
     *            the class to adapt to
     * @return the adapted object
     */

    public static/* <T> T */Object adapt(Object object, Class/* <T> */type) {
        if (type.isInstance(object)) {
            return /* (T) */object;
        } else if (object instanceof IAdaptable) {
            return /* (T) */((IAdaptable) object).getAdapter(type);
        }
        return /* (T) */Platform.getAdapterManager().getAdapter(object, type);
    }

    /**
     * Returns the plugin's resource bundle,
     */
    public ResourceBundle getResourceBundle() {
        try {
            if (resourceBundle == null) {
                resourceBundle = ResourceBundle
                        .getBundle("org.apache.ivyde.eclipse.IvyPluginResources");
            }
        } catch (MissingResourceException x) {
            resourceBundle = new ResourceBundle() {
                protected Object handleGetObject(String key) {
                    return null;
                }

                public Enumeration getKeys() {
                    return Collections.enumeration(Collections.EMPTY_LIST);
                }

            };
        }
        return resourceBundle;
    }

    /**
     * Returns an image descriptor for the image file at the given plug-in relative path.
     * 
     * @param path
     *            the path
     * @return the image descriptor
     */
    public static ImageDescriptor getImageDescriptor(String path) {
        return AbstractUIPlugin.imageDescriptorFromPlugin(ID, path);
    }

    /**
     * @return the helper around the plugin preference store
     */
    public static IvyDEPreferenceStoreHelper getPreferenceStoreHelper() {
        return plugin.prefStoreHelper;
    }

    public IvyConsole getConsole() {
        return console;
    }

    public BundleContext getBundleContext() {
        return this.bundleContext;
    }

    public ColorManager getColorManager() {
        return colorManager;
    }

    public IvyMarkerManager getIvyMarkerManager() {
        return ivyMarkerManager;
    }

    public IvyClasspathContainerSerializer getIvyClasspathContainerSerializer() {
        return ivyCpcSerializer;
    }

    public IvyAttachementManager getIvyAttachementManager() {
        return ivyAttachementManager;
    }

    public IvyResolveJob getIvyResolveJob() {
        return ivyResolveJob;
    }

    public RetrieveSetupManager getRetrieveSetupManager() {
        return retrieveSetupManager;
    }

    public boolean isIvyVersionGreaterOrEqual(int major, int minor, int patch) {
        if (ivyVersionMajor > major) {
            return true;
        } else if (ivyVersionMajor < major) {
            return false;
        }
        // ivyVersionMajor == major
        if (ivyVersionMinor > minor) {
            return true;
        } else if (ivyVersionMinor < minor) {
            return false;
        }
        // ivyVersionMinor == minor
        if (ivyVersionPatch >= patch) {
            return true;
        } else {
            return false;
        }
    }
}