/* | |
* 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)); | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} |