path: root/src/plugins/logger/src/com/motorola/studio/android/logger/internal/EclipseEnvironmentManager.java

/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed 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 com.motorola.studio.android.logger.internal;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.apache.log4j.PropertyConfigurator;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IBundleGroup;
import org.eclipse.core.runtime.IBundleGroupProvider;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.osgi.framework.Bundle;

import com.motorola.studio.android.logger.Logger;

/**
 * EclipseEnvironmentManager logs the Eclipse environment information such as
 * all plug-ins available on runtime. It logs the Virtual Machine information as
 * well by calling the VMEnvironmentManager class method.
 */
public class EclipseEnvironmentManager implements EnvironmentManager
{

    /**
     * The configuration element
     */
    private static final String CONFIGURATION = "configuration"; //$NON-NLS-1$

    /**
     * Log file name.
     */
    public static final String PROPERTY = "logger.properties"; //$NON-NLS-1$

    /**
     * Platform Logger appender.
     */
    public static final String DEFLOG_FILE = "log4j.appender.default.File"; //$NON-NLS-1$

    /**
     * Platform Environment Logger appender.
     */
    public static final String ENVLOG_FILE = "log4j.appender.envconf.File"; //$NON-NLS-1$

    /**
     * Logs the environment
     */
    public void logEnvironment()
    {
        IBundleGroup[] bundleGroup;
        Bundle[] bundles;
        Bundle bundle;

        /* Map with all extensions configurations. */
        Map<String, String> log4jPropertiesMap = new LinkedHashMap<String, String>();
        Properties log4jProperties = new Properties();

        try
        {
            /* Reads configuration extension point extensions */
            this.getExtensionsConfiguration(log4jPropertiesMap);
            this.getPlatformConfiguration(log4jPropertiesMap);
        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }

        /* Builds a properties with all configurations */
        Set<String> keys = log4jPropertiesMap.keySet();
        for (String key : keys)
        {
            log4jProperties.setProperty(key, log4jPropertiesMap.get(key));
        }
        PropertyConfigurator.configure(log4jProperties);

        /* Logs the Environment */
        new VMEnvironmentManager().logEnvironment();

        Logger envLogger = Logger.getLogger("com.motorola.studio.environment"); //$NON-NLS-1$
        IBundleGroupProvider[] registry = Platform.getBundleGroupProviders();
        envLogger.info("--------------------------------------"); //$NON-NLS-1$
        envLogger.info("## Eclipse Plug-ins Log Information ##"); //$NON-NLS-1$
        envLogger.info("--------------------------------------"); //$NON-NLS-1$
        for (int i = 0; i < registry.length; i++)
        {
            bundleGroup = registry[i].getBundleGroups();
            for (int j = 0; j < bundleGroup.length; j++)
            {
                bundles = bundleGroup[j].getBundles();
                for (int k = 0; k < bundles.length; k++)
                {
                    bundle = bundles[k];
                    Dictionary<String, String> values = bundle.getHeaders();
                    envLogger.info(bundle.getSymbolicName() + " - " + //$NON-NLS-1$ 
                            values.get("Bundle-Version")); //$NON-NLS-1$
                }
            }
        }
    }

    /**
     * Getter of the workspace path
     * 
     * @return The workspace path
     */
    private File getLogsFolder()
    {
        IPath workspacePath = Activator.getDefault().getStateLocation();
        File file = null;
        if (workspacePath != null)
        {
            file = workspacePath.toFile();
        }
        return file;
    }

    /**
     * Loads the Platform configuration.
     * 
     * @param log4jPropertiesMap Map to append properties keys and values.
     * @throws IOException if any IO error occurs.
     */
    private void getPlatformConfiguration(Map<String, String> log4jPropertiesMap)
            throws IOException
    {
        /* Reads the default configuration. */
        Activator activator = Activator.getDefault();
        if (activator != null)
        {
            URL bundleUrl = activator.getBundle().getEntry(PROPERTY);
            if (bundleUrl != null)
            {
                Properties props = new Properties();
                props.load(bundleUrl.openStream());

                File logs = this.getLogsFolder();
                if (!logs.exists())
                {
                    throw new RuntimeException("State folder does not exist."); //$NON-NLS-1$
                }

                String logFileName = props.getProperty(DEFLOG_FILE);
                String envFileName = props.getProperty(ENVLOG_FILE);
                if ((logFileName != null) && (envFileName != null))
                {
                    File logFile = new File(logs.getAbsolutePath() + File.separator + logFileName);
                    File envFile = new File(logs.getAbsolutePath() + File.separator + envFileName);
                    props.setProperty(DEFLOG_FILE, logFile.getAbsolutePath());
                    props.setProperty(ENVLOG_FILE, envFile.getAbsolutePath());

                    Enumeration<Object> keys = props.keys();
                    while (keys.hasMoreElements())
                    {
                        String key = (String) keys.nextElement();
                        String value = props.getProperty(key);
                        if (value != null)
                        {
                            log4jPropertiesMap.put(key, value);
                        }
                    }
                }
                else
                {
                    throw new RuntimeException("Logger property file is corrupted."); //$NON-NLS-1$
                }
            }
            else
            {
                throw new RuntimeException("Could not get logger.properties URL."); //$NON-NLS-1$
            }
        }
        else
        {
            throw new RuntimeException(
                    "Could not get com.motorola.studio.platform.logger activator."); //$NON-NLS-1$
        }
    }

    /**
     * Loads all configuration extension point extensions to read properties
     * files.
     * 
     * @param log4jPropertiesMap Map to append properties keys and values.
     */
    private void getExtensionsConfiguration(Map<String, String> log4jPropertiesMap)
    {
        IExtensionRegistry registry = Platform.getExtensionRegistry();
        IExtensionPoint extPoint = registry.getExtensionPoint(Activator.PLUGIN_ID, CONFIGURATION);
        IExtension[] exts = extPoint.getExtensions();

        for (int i = 0; i < exts.length; i++)
        {
            IExtension ext = exts[i];
            if (ext != null)
            {
                IConfigurationElement[] configuration = ext.getConfigurationElements();
                for (int j = 0; j < configuration.length; j++)
                {
                    IConfigurationElement config = configuration[j];
                    if ((config != null) && config.getName().equals(CONFIGURATION))
                    {
                        String file = config.getAttribute("file"); //$NON-NLS-1$
                        if ((file != null) && (file.length() > 0))
                        {
                            Bundle plugin = Platform.getBundle(ext.getNamespaceIdentifier());
                            if (plugin != null)
                            {
                                URL url = plugin.getEntry(file);
                                if (url != null)
                                {
                                    InputStream stream = null;
                                    Properties props = null;
                                    try
                                    {
                                        stream = FileLocator.toFileURL(url).openStream();
                                        props = new Properties();
                                        props.load(stream);
                                    }
                                    catch (IOException e)
                                    {
                                        /*
                                         * In case the custom configuration file
                                         * can not be read the default will be
                                         * used.
                                         */
                                        Activator
                                                .getDefault()
                                                .getLog()
                                                .log(new Status(
                                                        IStatus.WARNING,
                                                        ext.getNamespaceIdentifier(),
                                                        0,
                                                        ext.getNamespaceIdentifier()
                                                                + " can not be loaded, using default configuration.", e)); //$NON-NLS-1$
                                    }
                                    finally
                                    {
                                        try
                                        {
                                            stream.close();
                                        }
                                        catch (IOException e)
                                        {
                                            e.printStackTrace();
                                        }
                                    }

                                    if (props != null)
                                    {
                                        Enumeration<Object> keys = props.keys();
                                        while (keys.hasMoreElements())
                                        {
                                            String key = (String) keys.nextElement();
                                            String value = props.getProperty(key);
                                            if (key.startsWith("log4j.appender.") && key.endsWith(".File")) { //$NON-NLS-1$ //$NON-NLS-2$
                                                File logs = this.getLogsFolder();
                                                if (logs != null)
                                                {
                                                    value =
                                                            logs.getAbsolutePath() + File.separator
                                                                    + value;
                                                    File customLogFile = new File(value);
                                                    if (customLogFile.exists())
                                                    {
                                                        customLogFile.delete();
                                                    }
                                                }
                                            }
                                            if (value != null)
                                            {
                                                log4jPropertiesMap.put(key, value);
                                            }
                                        }
                                    }

                                }
                                else
                                {
                                    Activator
                                            .getDefault()
                                            .getLog()
                                            .log(new Status(
                                                    IStatus.WARNING,
                                                    ext.getNamespaceIdentifier(),
                                                    0,
                                                    "Could not load " + //$NON-NLS-1$ 
                                                            file
                                                            + " from " + ext.getNamespaceIdentifier() + //$NON-NLS-1$ 
                                                            " plugin.", //$NON-NLS-1$
                                                    null));
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}