Attachment #87054 for bug #208728

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/**********************************************************************
 * Copyright (c) 2005,2007 IBM Corporation and others.
 * 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
 * $Id
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.internal.importer;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import org.eclipse.hyades.logging.adapter.impl.AdapterXMLConstants;
import org.eclipse.hyades.logging.adapter.util.AdapterConstants;
import org.eclipse.hyades.logging.adapter.util.Messages;
import org.eclipse.hyades.logging.parsers.LogParserException;
import org.eclipse.hyades.logging.parsers.ParserConstants;
import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;

/**
 * Helper class for finding the GLA adapter configuration file.
 * 
 * @author apnan
 *
 */
public class GLAHelper {

	protected static short platform = -1;//flag indicating whether the code runs in the workbench or outside the workbench
										// the values that this flag can have are:
										// -1: GLAHelper wasn't initialized
										// 0: GLAHelper runs outside the workbench
										// 1: GLAHelper runs in the workbench
	
	/**
	 * Get the adapter configuration file path.
	 * @param table the parser parameters hash stable
	 * @param nameSpace the plugin name if running in the workbench, null otherwise
	 * @param useOriginalAdapter boolean to indicate to use the original adapter file specification
	 * stored in the hash table with key originalAdapter
	 * @return the adapter file path. 
	 * @throws LogParserException
	 */
	public static synchronized String getAdapterPath(Map table, String nameSpace, boolean useOriginalAdapter) throws LogParserException{
		
		String key; 
		
		if (useOriginalAdapter) {
			key = LogParserConstants.ORIGINAL_ADAPTER_KEY;
		}
		else {
			key = getAdapterPathKey(table);
			if(key==null){
				String message = Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", (String)null); 
				throw new LogParserException(message);
			}
			if(GLADebug.INSTANCE.debug){
				GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: adapter key="+key);			
			}
		}
		
		String config_file = (String)table.get(key);

		//get the adapter config file path
		String adapterFilePath = "";
		
		if(config_file.indexOf("./")>-1){
			config_file = config_file.substring(2);			
		}
		
		/* If running in an eclipse workbench environment then try to get the adapter file
		 * path based on the plugin bundle.
		 */
		if(isWorkbenchMode()){
			try {
				// Bundle bundle = Platform.getBundle(nameSpace);
				Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
	            Method getBundle = platformClass.getMethod("getBundle", new Class[]{String.class});
	            Object bundle = getBundle.invoke(null, new String[]{nameSpace});
	            Class pathClass = Class.forName("org.eclipse.core.runtime.IPath");
	            Class bundleClass = Class.forName("org.osgi.framework.Bundle");
	            Method find = platformClass.getMethod("find", new Class[]{bundleClass, pathClass});
				
				if(bundle!=null){
					//verify if the adapter is NL enabled
					if(config_file.indexOf("/nl/")>-1){
						config_file = getNLAdapterPath(table, config_file, find, bundle);
						if(config_file==null){
							String message = Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", (String)table.get(key)); 
							throw new Exception(message);
						}
						adapterFilePath = config_file; 
					}else{				
						URL fileURL = find(find, bundle, config_file);
						if(fileURL==null){
							//config_file = "config/"+config_file;
							fileURL = find(find, bundle, "config/"+config_file);
						}
						if(fileURL!=null){
							adapterFilePath = fileURL.toString();
						}else{
							/* Try using the config file root from the hash table if Log Import Wizard modified the
							 * adapter with a filter. */
							adapterFilePath = (String) table.get(LogParserConstants.CONFIG_FILE_ROOT_KEY) + "/" + config_file;			
							File test = new File(adapterFilePath);
							if(!test.exists()){
								// Couldn't find adapter file so throw an exception
								throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", config_file));
							}
						}
					}
				}else{
					adapterFilePath = config_file; 
				}
			}
			catch (Throwable e) {
				// Capture the exception in a LogParserException
				throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", config_file),e);
			}
			
		}
		/* Else find the adapter file path based on path variables in the hash table */
		else{
			
			//verify if the adapter is NL enabled
			if(config_file.indexOf("/nl/")>-1){
				if(GLADebug.INSTANCE.debug){
					GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: trying to get the nl adapter file using base file "+config_file);			
				}
				config_file = getNLAdapterPath(table, config_file, null, null);
				if(config_file==null){
					String message = Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", (String)table.get(key)); 
					throw new LogParserException(message);
				}
				adapterFilePath = config_file; 
			}else{
				String adapterPath = (String)table.get(LogParserConstants.CONFIG_FILE_ROOT_KEY) ;
				
//				//check to see if the global properties are set
//				if (adapterPath == null){
//					adapterPath = CBEConfigurationProperties.instance().getProperties().getProperty(CBEConfigurationProperties.ADAPTER_LOCATION);
//				}
				adapterFilePath = adapterPath + "/" + config_file;
				if(GLADebug.INSTANCE.debug){
					GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: try to find the adapter file using ConfigFileRoot path eg. "+adapterFilePath);			
				}
				File test = new File(adapterFilePath);
				if(!test.exists()){
					adapterFilePath = adapterPath + "config/"+config_file;
					if(GLADebug.INSTANCE.debug){
						GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: try to find the adapter file using ConfigFileRoot path plus config eg. "+adapterFilePath);			
					}
					test = new File(adapterFilePath);
					if(!test.exists()){
						// last attempt 
						//
						// Bug 62317
						// Try to resolve the config file using the command line list of directories
						//
						String config_paths = (String)table.get(LogParserConstants.CONFIG_PATH_KEY); // get the paths containing the adapter files

						// Check to ensure config_path was set in the input table
						// If it is not then throw an appropriate exception.
						if (config_paths != null && config_paths.length() != 0) {
							StringTokenizer strtok = new StringTokenizer(config_paths, File.pathSeparator, false); // tokenize the path
							while(strtok.hasMoreTokens()) {
								String config_path = strtok.nextToken();

								if(GLADebug.INSTANCE.debug){
									GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: try to find the adapter file " + config_file + " using config_path "+config_path);			
								}
								File f = new File(config_path, config_file); // look for the adapter file using the path
								if(f.exists()) {									
//									table.remove(LogParserConstants.CONFIG_PATH_KEY); // This is no longer required									
									adapterFilePath = f.getAbsolutePath();
									return adapterFilePath;
								}
							}
						}
						// Bug 62317 ends

						if(GLADebug.INSTANCE.debug){
							GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: could not find the adapter file!  Throwing an exception.");			
						}
						throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", config_file));
						
					}
				}			
			}
		}		
		return adapterFilePath;		
	}
	/**
	 * Initializes the context in which this class is running.
	 * Determines whether the code runs in a workbench context or outside. 
	 * Calling this method is required before using the adapter path helper method.
	 *
	 */
	protected static synchronized void initialize(){
		try {
            Class resourcePlugin = Class.forName("org.eclipse.core.resources.ResourcesPlugin");
            Method getWorkspace = resourcePlugin.getMethod("getWorkspace", null);
            Object workspace = getWorkspace.invoke(null, null);
            Method getRoot = workspace.getClass().getMethod("getRoot", null);
            Object root = getRoot.invoke(workspace, null);

            platform =(short)((root != null) ? 1 : 0);
        } catch (ClassNotFoundException e) {
        	platform = 0;
        } catch (SecurityException e) {
        	platform = 0;
        } catch (NoSuchMethodException e) {
        	platform = 0;
        } catch (IllegalArgumentException e) {
        	platform = 0;
        } catch (IllegalAccessException e) {
        	platform = 0;
        } catch (InvocationTargetException e) {
        	platform = 0;
        } catch (NullPointerException e) {
        	platform = 0;
        }
	}

	/**
	 * Get the absolute path of the adapter configuration file.
	 * @param table the parser parameters hash stable
	 * @param nameSpace the plugin name if running in the workbench, null otherwise
	 * @param useOriginalAdapter boolean to indicate to use the original adapter file specification
	 * stored in the hash table with key originalAdapter
	 * @return the absolute path of the adapter file. 
	 * @throws LogParserException
	 */
	public static synchronized String getAbsoluteAdapterPath(Map table, String nameSpace, boolean useOriginalAdapter) throws LogParserException{
		String adapterPath = getAdapterPath(table, nameSpace, useOriginalAdapter);
		
		/* If running in eclipse workbench environment Then the adapter path returned by getAdapterPath may
		 * be a URL based on the plugin bundle.  In that case it needs to be converted to an
		 * absolute file path.
		 */
		if(isWorkbenchMode()){
			try{
				Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
	            Method asLocalURL = platformClass.getMethod("asLocalURL", new Class[]{URL.class});
	            URL adapterURL = new URL(adapterPath);
	            URL absoluteURL = (URL)asLocalURL.invoke(null, new Object[]{adapterURL});
	            return absoluteURL.getFile();
			}catch (MalformedURLException ue) {
				/* Assume that the path returned by getAdapterPath is not a URL but is already an absolute path for
				 * the adapter file.  Iit will be returned.
				 */
			}catch (Throwable e) {
				// Capture the exception in a LogParserException
				throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", adapterPath),e);
			}

			
		}
		return adapterPath;
	}
	/**
	 * Get the key that is used to find the adapter configuration file name in the hash table.
	 * @param table the parser parameters hash table
	 * @return the hash table key corresponding to the adapter file path, null if no adapter
	 * file path found.
	 */
	public static synchronized String getAdapterPathKey(Map table){
		String key = null;
		String version = (String) (table.get(ParserConstants.APPLICATION_VERSION_KEY));
		String config_file = null;
		
		// If no version attribute given, use default
		if(version == null)
		{
			version = LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY;
		}

		// Get the config file defined for this version
		config_file =  (String) (table.get(version));
		
		if(config_file == null && version != LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY)
		{
			// Cannot find the corresponding config file, use default
			config_file = (String) (table.get(LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY));
			
			// If the default file is the desired adapter file then set the key to return 
			if(config_file != null) { 
				key = LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY;
			}			
		}
		else if (config_file != null) {
			key = version;
		}

		return key;
	
	}
	
	/**
	 * 
	 * @return boolean whether object is executing in an Eclipse workbench environment
	 */
	public static synchronized boolean isWorkbenchMode(){
		if(platform==-1){
			initialize();
		}
		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("workbench="+platform);			
		}
		
		return platform ==1;
	}
	
	/**
	 * Get the adapter configuration file path based on locale and encoding.
	 * @param table Hash table of input parameters
	 * @param configFilePath The adapter configuration file to find.
	 * @param find The method to find the file
	 * @param bundle - plugin bundle
	 * @return the adapter configuration file path
	 */
	protected static synchronized String getNLAdapterPath(Map table,
			String configFilePath, Method find, Object bundle){

		String characterEncoding = (String) table
				.get(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_CHARACTER_ENCODING);
		String countryCode = (String) table
				.get(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_ISO_COUNTRY_CODE);
		String languageCode = (String) table
				.get(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_ISO_LANGUAGE_CODE);

		String locale = null;
		/*
		 * bugzilla 135799
		 * Get the default system locale and character encoding if the default string is 
		 * passed in.
		 */
		if (languageCode != null && languageCode.equals(AdapterConstants.AttributeValue_Default)) {
			languageCode = Locale.getDefault().getLanguage();
		}
		if (countryCode != null && countryCode.equals(AdapterConstants.AttributeValue_Default)) {
			countryCode = Locale.getDefault().getCountry();
		}

		if (characterEncoding != null && characterEncoding.equals(AdapterConstants.AttributeValue_Default)) {
			try {
				characterEncoding = System.getProperty("file.encoding");
			}
			catch (SecurityException e) {
				/* null file encoding will be handled below */
			}
		}
		if(countryCode!=null && countryCode.length() == 0){
			locale = languageCode;
		}else if(countryCode!=null && languageCode!=null){
			locale = languageCode + "_" + countryCode;
		}

		int i = configFilePath.indexOf("/nl/");
		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("characterEncoding="+characterEncoding);
			GLADebug.INSTANCE.log("countryCode="+countryCode);
			GLADebug.INSTANCE.log("languageCode="+languageCode);
		}
		
		// try to find the adapter in the following order
		// <root>/nl/<ISOLanguageCode>_<ISOCountryCode>/<characterEncoding>
		// <root>/nl/<ISOLanguageCode>_<ISOCountryCode>
		// <root>/nl/<characterEncoding>
		// <root>/nl/
		
		String[][] searchPath = new String[][]{{locale, characterEncoding}, {locale}, {characterEncoding}, {"/"}};
		if (i < 0) {
			return configFilePath;
		}
		int j = configFilePath.lastIndexOf('/');
		String dir = configFilePath.substring(0, i + 3);
		String fileName = configFilePath.substring(j);
		
		StringBuffer path = new StringBuffer();
		String[] currentPath = null;
		int l = 0;

		String fullPath = null;
		String lastPathAppended = null;
		for(int idx=0;idx<4 && fullPath==null;idx++){
			currentPath = searchPath[idx];
			l = currentPath.length;
			path.append(dir);
			for(int jdx=0;jdx<l;jdx++){				
				if(currentPath[jdx]==null){
					continue;
				}
				if(!currentPath[jdx].equals("/")){
					path.append('/');
				}
				path.append(currentPath[jdx]);
				lastPathAppended = currentPath[jdx];
			}
			if(lastPathAppended!=null && lastPathAppended.equals("/")){
				path.append(fileName.substring(1));
			}else{
				path.append(fileName);
			}
			fullPath = getPath(table, find, bundle, path.toString());
			path.setLength(0);
		}

		return fullPath;
	}
	
	/**
	 * Get the full path of the adapter configuration file
	 * @param table Hash table of input parameters
	 * @param find The method to use to find the URL
	 * @param bundle The plugin bundle
	 * @param configFilePath
	 * @return the full path of the adapter file
	 */
	protected static synchronized String getPath(Map table, Method find, Object bundle, String configFilePath){
		String filePath = null;
		if(bundle!=null){
			// workbench context mode: local import
			URL fileURL = find(find, bundle, configFilePath);
			if(fileURL==null){
				fileURL = find(find, bundle, "config/"+configFilePath);
			}
			if (fileURL != null) {
				filePath = fileURL.toString();
			}
		}else{
			// outside workbench context: remote import or web client
			String adapterPath = (String)table.get(LogParserConstants.CONFIG_FILE_ROOT_KEY) ;
			
//			//check to see if the global properties are set
//			if (adapterPath == null){
//				adapterPath = CBEConfigurationProperties.instance().getProperties().getProperty(CBEConfigurationProperties.ADAPTER_LOCATION);
//			}
			
			String adapterFilePath = adapterPath + "/" + configFilePath;
			File file = new File(adapterFilePath);
			if(file.exists()){
				filePath = adapterFilePath;
			}else {
				String config_paths = (String)table.get(LogParserConstants.CONFIG_PATH_KEY); // get the paths containing the adapter files
				if (config_paths != null && config_paths.length() != 0) {
					StringTokenizer strtok = new StringTokenizer(config_paths, File.pathSeparator, false); // tokenize the path
					while(strtok.hasMoreTokens()) {
						String config_path = strtok.nextToken();

						File f = new File(config_path, configFilePath); // look for the adapter file using the path
						if(f.exists()) {
							filePath = f.getAbsolutePath();
						}
					}
				}	
			}		
		}
		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("GLAHelper.getPath: Attempted to get adapter at path "+configFilePath +" result: file=" +filePath);
		}

		return filePath;
	}
	
	/**
	 * Find the URL of the adapter configuration file
	 * @param find The method to find the adapter file
	 * @param bundle - The plugin bundle
	 * @param config_file - the adapter configuration file to find
	 * @return the URL of the adapter configuration file
	 */
	protected static URL find(Method find, Object bundle, String config_file){
		URL fileURL = null;
		Class pathClass;
		try {
			pathClass = Class.forName("org.eclipse.core.runtime.Path");
			Constructor pathConstructor = pathClass.getConstructor(new Class[] {config_file.getClass()});
			Object path = pathConstructor.newInstance(new Object[] {config_file});
			fileURL = (URL)find.invoke(null, new Object[]{bundle, path});
			
		} catch (Exception e) {			
			if(GLADebug.INSTANCE.debug)
				e.printStackTrace();
		}
		return fileURL;
		
	}
	
}




/**********************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * 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
 * $Id: GLALoggerFactory.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.internal.importer;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogConfigurationException;
import org.eclipse.hyades.logging.commons.LoggerFactory;

/**
 * This class extends org.eclipse.hyades.logging.commons.LoggerFactory
 * to instantiate the org.eclpise.hyades.logging.parsers.GLALogger class.
 * 
 * @see org.apache.commons.logging.LogFactory
 * @see org.eclipse.hyades.logging.commons.Logger
 * @see org.eclipse.hyades.logging.commons.LoggerFactory
 * @see org.eclipse.hyades.logging.parsers.internal.importer.GLALogger
 */
public class GLALoggerFactory extends LoggerFactory {

    /**
     * No-argument constructor.
     */
    public GLALoggerFactory() {
        super();
    }

    /**
     * Returns an instance of a non-null named
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code> based on the
     * parameter name.
     * <p>
     * Passing a <code>null</code> logger name results in a <code>null</code>
     * return value.
     * <p>
     * An instance of a named
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code> is created if no
     * named instance current exists or all instances have been released.
     * <p>
     * Once a named <code>org.eclipse.hyades.logging.parsers.GLALogger</code> is
     * created, the instance is cached for future calls to retrieve the same
     * named <code>org.eclipse.hyades.logging.parsers.GLALogger</code>.
     * <p>
     * The name of the <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     * uniquely identifies an instance of an
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code>. All subsequent
     * calls will return the same instance of the named
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code>.
     * <p>
     * 
     * @param loggerName
     *            The non-null name of the returned
     *            <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     *            instance.
     * @return A named <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     *         instance, otherwise <code>null</code> if the parameter logger
     *         name is <code>null</code>.
     * @exception LogConfigurationException
     *                if the named
     *                <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     *                instance could not be created.
     * @see org.apache.commons.logging.LogFactory#getInstance(java.lang.String)
     */
    public Log getInstance(String loggerName) throws LogConfigurationException {

        if (loggerName != null) {

            if (loggers.containsKey(loggerName)) { return (((Log) (loggers.get(loggerName)))); }

            GLALogger logger = new GLALogger(loggerName);

            loggers.put(loggerName, logger);

            return logger;
        }

        return null;
    }
}




/**********************************************************************
 * Copyright (c) 2005, 2006 IBM Corporation and others.
 * 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
 * $Id: LocalLogParserLoader.java,v 1.1 2006/08/23 21:17:51 sleeloy Exp $
 *
 * Contributors:
 * IBM - Initial API and implementation
 **********************************************************************/
package org.eclipse.hyades.logging.parsers.internal.importer;

import java.io.UnsupportedEncodingException;
import java.util.Hashtable;

import org.apache.commons.logging.Log;
import org.eclipse.hyades.internal.logging.core.Constants;
import org.eclipse.hyades.logging.events.cbe.util.EventFormatter;
import org.eclipse.hyades.logging.events.cbe.util.EventHelpers;
import org.eclipse.hyades.logging.parsers.importer.ILogParser;

public class LocalLogParserLoader extends LocalLogImportLoader{

    //~ Constructors -------------------------------------------------------------------------------

    public LocalLogParserLoader(ILogParser parser, Hashtable parserParameters, boolean traceXML) {
    	super(parser, parserParameters, traceXML);
    	loggingLevel=0;
    }

    //~ Methods ------------------------------------------------------------------------------------

    
    public Log getParserLogger(){
    	return logParser;
    }

    //NOTE: Temporary API to propagate logged raw objects to the model as XML strings:
    private void logXMLToModel(String xml) {
        // Note:  L0DocumentEventHandler (perftrace.loader.XMLLoader) XML scanner MUST be passed UTF8 encoded byte array data:
        byte[] xmlLogEntryBytes = null;

        try {
            xmlLogEntryBytes = xml.getBytes("UTF8");
        }
        catch (UnsupportedEncodingException u) {
            xmlLogEntryBytes = xml.getBytes();
        }

        //		System.err.println(xml);
        xmlLoader.loadEvent(xmlLogEntryBytes, xmlLogEntryBytes.length);
    }
    
	/**
	 * Logs the parameter <code>java.lang.Object</code> log record to the Logging Agent 
	 * with the same name as the logger if TRACE logging is currently enabled.  
	 * 
	 * The log record is first converted to XML and then sent to the Logging Agent.
	 * 
	 * @param record The log record to be logged to the Logging Agent.
	 */

	public void trace(Object record) {
//		try {
			if (isTraceEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void trace(Object record, Throwable throwable) {
//		try {
			if (isTraceEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void debug(Object record) {
//		try {
			if (isDebugEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void debug(Object record, Throwable throwable) {
//		try {
			if (isDebugEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void info(Object record) {
//		try {
			if (isInfoEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void info(Object record, Throwable throwable) {

//		try {
			if (isInfoEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


	public void warn(Object record) {
//		try {
			if (isWarnEnabled()) {
                if(!traceXML){	
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
                }else{
                	logXMLToModel((String)record);
                }
			}
//		}
//		catch (Throwable t) {
//		}
	}

	public void warn(Object record, Throwable throwable) {
//		try {
			if (isWarnEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}

	public void error(Object record) {
//		try {
			if (isErrorEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}

	public void error(Object record, Throwable throwable) {

//		try {
			if (isErrorEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


	public void fatal(Object record) {
//		try {
			if (isFatalEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


	public void fatal(Object record, Throwable throwable) {

//		try {
			if (isFatalEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


}
   





/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others. 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
 * $Id
 * 
 * Contributors: IBM - Initial API and implementation
 ******************************************************************************/

package org.eclipse.hyades.logging.parsers.internal.importer;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * This class provides debugging facilities for the Log Import code.
 * 
 * @author apnan
 *
 */
public class GLADebug {

	public boolean debug = false;
	public boolean logToFile = false;
	
	protected String plugin_name; 
	protected String value;
	protected final String NL = System.getProperties().getProperty("line.separator");
	private FileOutputStream log = null;

	public static GLADebug INSTANCE = new GLADebug("org.eclipse.hyades.logging.parsers");

	public GLADebug(String plugin_name) {
		this.plugin_name = plugin_name;
		init();
	}

	/**
	 * Initialize the debugging code.
	 *
	 */
	protected void init() {
		try {
			// Get the debugging options from the options file.		
			Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
            Method getDebugOption = platformClass.getMethod("getDebugOption", new Class[]{String.class});
            value = (String)getDebugOption.invoke(null, new String[]{plugin_name+"/debug"});
			
			if (value != null) {
				debug = value.equalsIgnoreCase("true");
			} else if(System.getProperty("GLADebug.debug")!=null)
			{
					debug = Boolean.valueOf(System.getProperty("GLADebug.debug")).booleanValue();
			}
			value = (String)getDebugOption.invoke(null, new String[]{plugin_name+"/logToFile"});
			if (value != null) {
				logToFile = value.equalsIgnoreCase("true");
			} else if(System.getProperty("GLADebug.logToFile")!=null)
			{
				logToFile = Boolean.valueOf(System.getProperty("GLADebug.logToFile")).booleanValue();
			}
			
			
		} catch (Exception e) {
			//	The platform is not available, read the environment variables
			debug = Boolean.valueOf(System.getProperty("GLADebug.debug")).booleanValue();
			logToFile = Boolean.valueOf(System.getProperty("GLADebug.logToFile")).booleanValue();
		}		
	}
	
	/**
	 * Get the debug log file output stream.
	 * 
	 * @return the FileOutputStream for the debug file
	 */
	public FileOutputStream getLog(){
		if(log==null){
			try {
				log = new FileOutputStream("./GLADebug-"+(new Date()).getTime());
			} catch (FileNotFoundException e) {
				if(debug)
					e.printStackTrace();
			}
		}else{
			if(!log.getChannel().isOpen())
			{
				try {
					log = new FileOutputStream("./GLADebug-"+(new Date()).getTime());					
				} catch (FileNotFoundException e) {
					if(debug)
						e.printStackTrace();
				}
			}
			
		}
		return log;
	}
	
	/**
	 * Log a debug message
	 * @param message
	 */
	public void log(String message){
		if(logToFile){
			// Log the message to the log file.
			try {
				getLog().write(message.getBytes());
				getLog().write(NL.getBytes());
			} catch (IOException e) {			
				if(debug)	
					e.printStackTrace();
			}
		}else{
			// Log the message to System.out
			System.out.println(message);
		}
	}
	
}




/**********************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * 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
 * $Id: GLALogger.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.internal.importer;

import org.eclipse.hyades.logging.commons.Logger;
import org.eclipse.hyades.logging.events.cbe.CommonBaseEvent;

/**
 * This class extends org.eclipse.hyades.logging.commons.Logger
 * so that it only logs the Common Base Event message instead of the
 * whole Common Base Event.  This class is used to log GLA messages.
 * 
 * @see org.apache.commons.logging.Log
 * @see org.apache.commons.logging.LogFactory
 * @see org.eclipse.hyades.logging.core.LoggingAgent
 * @see org.eclipse.hyades.logging.commons.Logger
 * @see org.eclipse.hyades.logging.commons.LoggerFactory
 */
public class GLALogger extends Logger {

    /**
     * Constructor to create a logger instance with a Logging Agent using the
     * parameter name.
     * 
     * NOTE: The default logging level is set to WARN until explicitly set.
     * 
     * @param name
     *            The name of the newly created logger.
     */
    public GLALogger(String name) {

        super(name);
 
    }

    /**
     * Logs the parameter <code>java.lang.Object</code> log record to the
     * Logging Agent with the same name as the logger if TRACE logging is
     * currently enabled.
     * 
     * If the log record is a CommonBaseEvent only the CommonBaseEvent message will be 
     * sent to the Logging Agent.  Otherwise it is assumed the record is a String.
     * 
     * @param record
     *            The log record to be logged to the Logging Agent.
     */
    public void trace(Object record) {

        if (isTraceEnabled()) {
        	if (record instanceof CommonBaseEvent) {
        		loggingAgent.write("glalog=" + ((CommonBaseEvent)record).getMsg());
        	}
        	else if (record instanceof String) {
        		loggingAgent.write((String)record);
        	}
        }
    }

    /**
     * Logs the parameter <code>java.lang.Object</code> log record and
     * <code>java.lang.Throwable</code> exception to the Logging Agent with
     * the same name as the logger if TRACE logging is currently enabled.
     * 
     * If the log record is a CommonBaseEvent only the CommonBaseEvent message will be 
     * sent to the Logging Agent.  Otherwise it is assumed the record is a String.
     * 
     * Only the parameter <code>java.lang.Object</code> log record is logged.
     * The <code>java.lang.Throwable</code> exception is ignored.
     * 
     * @param record
     *            The log record to be logged to the Logging Agent.
     * @param throwable
     *            The exception will be ignored
     */
    public void trace(Object record, Throwable throwable) {

        if (isTraceEnabled()) {
           	if (record instanceof CommonBaseEvent) {
        		loggingAgent.write("glalog=" + ((CommonBaseEvent)record).getMsg());
        	}
        	else if (record instanceof String) {
        		loggingAgent.write((String)record);
        	}
        }
    }

}




/**********************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * 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
 * $Id: StatusMonitor.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/
package org.eclipse.hyades.logging.parsers.internal.importer;

import org.apache.commons.logging.Log;

/**
 * This class is a runnable that checks the status of a log parser
 * at regular intervals and sends the status to a logging agent.
 */
public class StatusMonitor implements Runnable {

	// Class of the parser object
	private Class parserClass = null;
	
	// The parser object
	private Object parser = null;
	
	// The logging agent to write the status to.
	private Log statusLogger = null;
	
	/**
	 * Constructor with required parameters
	 * @param parser object that is doing the log parsing
	 * @param parserClass class of the parser object
	 * @param statusLogger logging agent to write the status to
	 */
	public StatusMonitor(Object parser, Class parserClass, Log statusLogger) {
		super();
		
		this.parser = parser;
		this.parserClass = parserClass;
		this.statusLogger = statusLogger;
	}

	/**
	 * Run this StatusMonitor thread.
	 * @see java.lang.Runnable#run()
	 */
	public void run() {
		String status = null;
		
		// Status checking loop.
		while (true) {
			try {
				// Get the status of the parsing object.
				status = (String)parserClass.getMethod("getStatus",null).invoke(parser, null);
			}
			catch (Exception e) {
				System.err.println("Exception occured when getting status: " + e.getMessage());
				status = null;
			}
			// write status string to status agent
			if (status != null) {
				statusLogger.trace(status);
			}
			
			// If this thread has been interrupted then quit the monitoring loop.
			if (Thread.interrupted()) {
				break;
			}
			
	   		/* Sleep for 2 seconds before checking the status again.
    		 * The parsing thread may interrupt this thread to indicate it is done so break
    		 * from the monitoring loop.
    		 */
            try {
            	Thread.sleep(2000);
            }
            catch (InterruptedException e) {
            	// Quit the monitoring loop if this thread has been interrupted
            	break;
            }
		}

	}

}




/**********************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 * Change History:
 **********************************************************************/
package org.eclipse.hyades.logging.parsers.internal.importer;

import java.util.Hashtable;

import org.apache.commons.logging.Log;
import org.eclipse.hyades.loaders.util.XMLLoader;
import org.eclipse.hyades.logging.parsers.LogParserException;
import org.eclipse.hyades.logging.parsers.importer.ILogParser;

/**
 * 
 * This is a specialized logger to be used by GLA for local log imports.  It is
 * instantiated by clients and passed to GLA via ParserWrapper.parse(Log) method.
 * Currently it is available internally only for use by the Log Import Wizard in
 * org.eclipse.tptp.monitoring.logui
 * 
 * @author Cindy Jin
 *
 */
public class LocalLogImportLoader  implements Log {


    protected Hashtable parserParameters = null;
    protected ILogParser parser = null;
    protected XMLLoader xmlLoader = null;
    protected Log logParser = null;
    protected boolean traceXML = false;

    /**
	 * Trace logging level value.
	 */
	public static final int TRACE_LEVEL = 0;

	/**
	 * Debug logging level value.
	 */
	public static final int DEBUG_LEVEL = 1;

	/**
	 * Information logging level value.
	 */
	public static final int INFO_LEVEL = 2;

	/**
	 * Warning logging level value.
	 */
	public static final int WARN_LEVEL = 3;

	/**
	 * Error logging level value.
	 */
	public static final int ERROR_LEVEL = 4;

	/**
	 * Fatal logging level value.
	 */
	public static final int FATAL_LEVEL = 5;

	/**
	 * The logger's current logging level value.
	 */
	protected int loggingLevel;
	public LocalLogImportLoader()
	{
		parser           = null;
		parserParameters = null;
	}

    public LocalLogImportLoader(ILogParser parser, Hashtable parserParameters, boolean traceXML) {
        this.parser = parser;
        this.parserParameters = parserParameters;
        this.traceXML = traceXML;
    }

    public void setXMLLoader(XMLLoader xmlLoader) {
    	 parserParameters.put("xmlLoader", xmlLoader);
        this.xmlLoader = xmlLoader;
    }
    
     
    public void startParsing() throws LogParserException {
        parser.setUserInput(parserParameters);
        parser.parse(this);
    }
    public void setParserLogger(Log logParser){
    	this.logParser = logParser;
    	parser.setParserLogger(logParser); 
    }
    
    public Log getParserLogger(){
    	return logParser;
    }

    public XMLLoader getXMLLoader()
    {
    	return xmlLoader;
    }
    
	public boolean isTraceEnabled() {
		return (loggingLevel<=TRACE_LEVEL);
	}

	public boolean isDebugEnabled() {
		return (loggingLevel<=DEBUG_LEVEL);
	}


	public boolean isInfoEnabled() {
		return (loggingLevel<=INFO_LEVEL);
	}

	public boolean isWarnEnabled() {
		return (loggingLevel<=WARN_LEVEL);
	}

	public boolean isErrorEnabled() {
		return (loggingLevel<=ERROR_LEVEL);
	}

	public boolean isFatalEnabled() {
		return (loggingLevel<=FATAL_LEVEL);
	}

	 
	public void trace(Object record) {
	}

	public void trace(Object record, Throwable throwable) {
	}

	public void debug(Object record) {
	}

	public void debug(Object record, Throwable throwable) {
	}

	public void info(Object record) {
	}

	public void info(Object record, Throwable throwable) {
	}


	public void warn(Object record) {
	}

	public void warn(Object record, Throwable throwable) {
	}

	public void error(Object record) {
	}

	public void error(Object record, Throwable throwable) {
	}


	public void fatal(Object record) {

	}


	public void fatal(Object record, Throwable throwable) {

	}
	
	
}




/**********************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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
 * $Id: LocalGLALogger.java,v 1.2 2006/09/20 19:20:23 dnsmith Exp $
 *
 * Contributors:
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.internal.importer;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.eclipse.hyades.logging.events.cbe.CommonBaseEvent;

public class LocalGLALogger implements Log {

	//private XmlGenerator xmlGenerator = new XmlGenerator();
	private List events = new ArrayList();
	private  final String NL = System.getProperties().getProperty("line.separator");
	
	private String detailMessage = null;

	/**
	 * Trace logging level value.
	 */
	public static final int TRACE_LEVEL = 0;

	/**
	 * Debug logging level value.
	 */
	public static final int DEBUG_LEVEL = 1;

	/**
	 * Information logging level value.
	 */
	public static final int INFO_LEVEL = 2;

	/**
	 * Warning logging level value.
	 */
	public static final int WARN_LEVEL = 3;

	/**
	 * Error logging level value.
	 */
	public static final int ERROR_LEVEL = 4;

	/**
	 * Fatal logging level value.
	 */
	public static final int FATAL_LEVEL = 5;

	/**
	 * The logger's current logging level value.
	 */
	private int loggingLevel;

	public LocalGLALogger() {
		//xmlGenerator.reset(null, true, 8);
		loggingLevel = 0;
	}

	public String getLogDetails() {
		StringBuffer buffer = new StringBuffer();
		synchronized(events){
			int s = events.size();
			String msg = null;
			if(s>0){
				for(int i=0;i<s-1;i++){
					msg = (String)events.get(i);
					if(msg!=null){
						buffer.append(msg);				
						buffer.append(NL);
					}			
				}
				msg = (String)events.get(s-1);
				if(msg!=null){
					buffer.append(msg);
				}
			}
		}
		detailMessage = buffer.toString();
		return detailMessage;
	}

	public boolean isDebugEnabled() {
		return (loggingLevel <= DEBUG_LEVEL);
	}

	public boolean isErrorEnabled() {
		return (loggingLevel <= ERROR_LEVEL);
	}

	public boolean isFatalEnabled() {
		return (loggingLevel <= FATAL_LEVEL);
	}

	public boolean isInfoEnabled() {
		return (loggingLevel <= INFO_LEVEL);
	}

	public boolean isTraceEnabled() {
		return (loggingLevel <= TRACE_LEVEL);
	}

	public boolean isWarnEnabled() {
		return (loggingLevel <= WARN_LEVEL);
	}

	public void trace(Object record) {
		if (isTraceEnabled()) {
			synchronized(events){
				if(record!=null && record instanceof CommonBaseEvent)
				if(((CommonBaseEvent)record).getMsg()!=null && !events.contains(((CommonBaseEvent)record).getMsg())){
					events.add(((CommonBaseEvent)record).getMsg());
				}
			}
//			this.detailMessage = xmlGenerator.objectToXML(record);
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void trace(Object record, Throwable arg1) {
		if (isTraceEnabled()) {
			trace(record);
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void debug(Object record) {
		if (isDebugEnabled()) {
			trace(record);
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void debug(Object record, Throwable arg1) {
		if (isDebugEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void info(Object record) {
		if (isInfoEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void info(Object record, Throwable arg1) {
		if (isInfoEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void warn(Object record) {
		if (isWarnEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void warn(Object record, Throwable arg1) {
		if (isWarnEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void error(Object record) {
		if (isErrorEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void error(Object record, Throwable arg1) {
		if (isErrorEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void fatal(Object record) {
		if (isFatalEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void fatal(Object record, Throwable arg1) {
		if (isFatalEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

}




               </documentation>
            </annotation>
         </attribute>
         <attribute name="override_id" type="string">
            <annotation>
               <documentation>
                  ID of logParser extension that this extension will override. Note, only those attributes included in this extension will be overridden.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="override_priority" type="string">
            <annotation>
               <documentation>
                  Numeric priority value used to evaluate the priority of this override extension in relation to other override extensions. A value of -1 indicates that the extension that is specified in override_id should be disabled and not available for use as a log parser. Note, this attribute is required if override_id is specified.  This attribute is ignored if override_id is not specified.
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>


      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         
      </documentation>
   </annotation>

   <annotation>
      <appInfo>

Lines 1-5 Link Here

(-)src.import/org/eclipse/hyades/logging/parsers/internal/adapter/formatters/LocalLogImportCBEFormatter.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 32-38 Link Here
32	import org.eclipse.hyades.logging.events.cbe.util.EventHelpers;	32	import org.eclipse.hyades.logging.events.cbe.util.EventHelpers;
33	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	33	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
34	import org.eclipse.hyades.logging.parsers.importer.ParserWrapper;	34	import org.eclipse.hyades.logging.parsers.importer.ParserWrapper;
35	import org.eclipse.hyades.logging.parsers.internal.importer.LocalLogImportLoader;	35	import org.eclipse.hyades.logging.parsers.provisional.importer.LocalLogImportLoader;
36		36
37	/**	37	/**
38	*	38	*




/**********************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others.
 * 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

	}

	/**
	 * Read the sensor configuration from the configuration element
	 * @param parserParameters Hashtable to put the sensor parameters in
	 * @see org.eclipse.hyades.logging.adapter.IComponent#update()
	 */
	protected void readConfiguration(Hashtable parserParameters) {
		// maximumBlocking is set by the sensor configuration
		// first get the basic configuration set
		super.update();
		// maximumBlocking is set by the sensor config
		String directory = null;
		String fileName = null;
		String className = null;

		String propertyName = null;
		String propertyValue = null;

		
		// Make a copy of the sensor properties to use as the parserParameters
		Hashtable sensorParameters = getProperties();
		Hashtable parserParameters = new Hashtable();
		
		// This sensor may be configured with a sub element of the config
		// or the sensor may be configured with sensor properties only.

		boolean propertiesPresent = false;
		// Get the sensor parameters from the sensor properties
		if (sensorParameters != null && !sensorParameters.isEmpty()) {
			// bugzilla 160528 - copy the sensor properties into the parserParamenters hash table because


			fileName = (String)parserParameters.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);
			
			parserClassName = (String)parserParameters.get(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName);									
			
		}	
		else if (element != null) {
			/**

								fileName = file;
						}	
						if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName))
							parserClassName = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName);
					
					    // Get the parameters from the sensor type instance properties
						sensorNodes = sensorNode.getChildNodes();

				}
			}
		}
	}

	/**
	 * Process the values read from the configuration and update the hash table of
	 * parameters if necessary.
	 * @param parserParameters Hashtable of sensor parameters
	 * @throws AdapterInvalidConfig
	 */
	protected void processConfiguration(Hashtable parserParameters) throws AdapterInvalidConfig {
		// We must have a directory and fileName
		if (directory == null || directory.length() == 0 || fileName == null || fileName.length() == 0 || parserClassName == null || parserClassName.length() == 0) {
			throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_StaticParserSensor_Invalid_Config_File_ERROR_"));
		}
		
		setDirectory(directory);
		setFileName(fileName);
		setParserClassName(parserClassName);
		
		// Construct the full input log file name
		if (getDirectory().endsWith(PATH_SEPARATOR)) {

		
		parserParameters.put(ParserConstants.CONTINUOUS_KEY, new Boolean(continuousContext));

		/* bugzilla 91489 - reset the directory and file name values in the hash
		 * table so the parser class can use them instead of file_path to handle
		 * regular expression values better.  The directory and file name values 
		 * may have been changed before getting to this point so they should be
		 * reset in the hash table.
		 */
		
		parserParameters.put(ParserConstants.DIRECTORY_KEY, directory);
		parserParameters.put(ParserConstants.FILE_NAME_KEY, fileName);
		}
		
		// Get the static parser class instance
		try {

	}
	
	/**
	 * Update the configuration based on the configuration Element
	 * @throws AdapterInvalidConfig if the configuration processing failed.
	 * @see org.eclipse.hyades.logging.adapter.IComponent#update()
	 */
	public void update() throws AdapterInvalidConfig
	{
		// first get the basic configuration set
		super.update();
		
		Hashtable parserParameters = new Hashtable();
		
		readConfiguration(parserParameters);
		
		processConfiguration(parserParameters);
	}
	
	/**
	 * 	simulates a getNext
	 * @see org.eclipse.hyades.logging.adapter.ISensor#testGetNext()
	 */

Lines 17-23 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
17	org.eclipse.hyades.logging.parsers.importer,	17	org.eclipse.hyades.logging.parsers.importer,
18	org.eclipse.hyades.logging.parsers.internal.adapter.formatters,	18	org.eclipse.hyades.logging.parsers.internal.adapter.formatters,
19	org.eclipse.hyades.logging.parsers.internal.adapter.outputters,	19	org.eclipse.hyades.logging.parsers.internal.adapter.outputters,
20	org.eclipse.hyades.logging.parsers.internal.importer	20	org.eclipse.hyades.logging.parsers.provisional.importer
21	Require-Bundle: org.eclipse.hyades.logging.core;bundle-version="[4.2.0,5.0.0)";visibility:=reexport,	21	Require-Bundle: org.eclipse.hyades.logging.core;bundle-version="[4.2.0,5.0.0)";visibility:=reexport,
22	org.eclipse.hyades.logging.adapter;bundle-version="[4.2.0,5.0.0)";visibility:=reexport,	22	org.eclipse.hyades.logging.adapter;bundle-version="[4.2.0,5.0.0)";visibility:=reexport,
23	org.eclipse.swt;bundle-version="[3.2.0,4.0.0)",	23	org.eclipse.swt;bundle-version="[3.2.0,4.0.0)",




package org.eclipse.hyades.logging.parsers.importer;

/**********************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others.
 * 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

import org.eclipse.hyades.logging.core.LoggingAgent;
import org.eclipse.hyades.logging.parsers.LogParserException;
import org.eclipse.hyades.logging.parsers.ParserUtilities;
import org.eclipse.hyades.logging.parsers.provisional.importer.GLADebug;
import org.eclipse.hyades.logging.parsers.provisional.importer.GLALogger;
import org.eclipse.hyades.logging.parsers.provisional.importer.GLALoggerFactory;
import org.eclipse.hyades.logging.parsers.provisional.importer.StatusMonitor;
/**
 * This class handles initialization (e.g. calling the setUserInput() API)
 * and invocation (e.g. calling the parse() API) of a remote log




/**********************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * 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

import org.eclipse.hyades.logging.parsers.ParserConstants;
import org.eclipse.hyades.logging.parsers.ParserUtilities;
import org.eclipse.hyades.logging.parsers.adapter.outputters.AdapterLogOutputter;
import org.eclipse.hyades.logging.parsers.provisional.importer.GLADebug;
import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;

	 * @return String - name of new config file
	 * @throws LogParserException 
	 */		
	protected String getNewConfigFile(Hashtable table) throws LogParserException
	{
		Document doc = null;


		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("ParserWrapper.getNewConfigFile: setting sensor properties.");			
		}

		/* Iterate through the components in the context instance and set any component
		 * properties with their corresponding values in the input hash table.
		 */ 
		NodeList contextInstanceList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);
		
		Element cIElement = (Element) contextInstanceList.item(0);
		NodeList componentList = cIElement.getChildNodes();
		int compCount = componentList.getLength();
		
		for (int i = 0; i<compCount; ++i) {
			if (componentList.item(i) instanceof Element) {
				Element compElement = (Element) componentList.item(i);
				String tagName = compElement.getTagName();
				System.out.println(tagName);
				Element sensorTypeInstance = null;
				String propValue;
				String propName;
				Element propertyElement;

				// If the component is a sensor Then set the appropriate sensor attributes and properties
				if (compElement.getTagName().equals(AdapterXMLConstants.ELEMENT_TAG_NAME_SENSOR)) {
					Element sensorElement = compElement;
					
					Element sensorNode;
					Element sensorPropertyElement;
					Element sensorTypeInstance = null;
					String newConverterCmd = null;

					Element directoryPropertyElement = null;
					Element fileNamePropertyElement = null;
					
					// Get the sensor children (properties or sensor type instances)
					NodeList sensorNodes = sensorElement.getChildNodes();
					for (int k = 0; k < sensorNodes.getLength(); k++) {
						if (sensorNodes.item(k).getNodeType() == Node.ELEMENT_NODE) {
							sensorNode = (Element) sensorNodes.item(k);
							// Process the sensor property
							if (sensorNode.getTagName().equals(AdapterXMLConstants.HyadesGAPropertyElementTagName)) {
								sensorPropertyElement = sensorNode;
								 */
								if (logFileDir != null) {
									sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, logFileDir);
								}									
							}
							else if (propName.equals(AdapterXMLConstants.HyadesGAfileNameAttributeName)) {
								// save property element so it can be set after converter processing
								fileNamePropertyElement = sensorPropertyElement;
								/* There might not be a log file if the converter command generates a file.
								 * If there is a log file then set the fileName property
								 */
								if (logFileName != null) {
									sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, logFileName);
								}									
							}
							else if (propName.equals(AdapterXMLConstants.HyadesGAconverterCmdAttributeName)) {
								if (propValue != null && propValue.length() > 0) {
									if (newConverterCmd == null) {
										newConverterCmd = modifyConverter(propValue, configFileDirectory, table, logFile);
										// ensure the new converter command is not null
										if (newConverterCmd == null) {
											newConverterCmd = "";
										}
									}
									sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, newConverterCmd);
								}
							}
							else {
								propValue = (String)table.get(propName);
								if(propValue != null)
								{
									sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, propValue.trim());
								}
							}
						}
						// Process the sensor type instance
						else if (sensorNode.getTagName().equals(AdapterXMLConstants.HyadesGAStaticParserSensorTagName) ||
								 sensorNode.getTagName().equals(AdapterXMLConstants.HyadesGASingleFileSensorTagName)) {
							sensorTypeInstance = sensorNode;
							// Get the sensor properties for this sensor type instance
							NodeList sensorPropertyList = sensorTypeInstance.getElementsByTagName(AdapterXMLConstants.HyadesGASensorPropertyElementTagName);
							int sensorPropertyCount = sensorPropertyList.getLength();
							for(int j = 0; j < sensorPropertyCount; ++j)
							{
								sensorPropertyElement = (Element) sensorPropertyList.item(j);
								propName = sensorPropertyElement.getAttribute(AdapterXMLConstants.HyadesGASensorPropertyNameAttributeName);
								propValue = (String)table.get(propName);
								if(propValue != null)
								{
									sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGASensorPropertyValueAttributeName, propValue.trim());
								}
							}

								propName = sensorPropertyElement.getAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName);
								propValue = sensorPropertyElement.getAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName);
								
								if (propName.equals(AdapterXMLConstants.HyadesGAdirectoryAttributeName)) {
									// save property element so it can be set after converter processing
									directoryPropertyElement = sensorPropertyElement;
								Node sensorTypeAttribute = sensorTypeAttributeList.item(j);
								String attrName = sensorTypeAttribute.getNodeName();
								// Modify the attribute based on user input
								if(attrName.equals(AdapterXMLConstants.HyadesGAdirectoryAttributeName))
								{
									/* There might not be a log file if the converter command generates a file.
									 * If there is a log file then set the directory property
									 */
									if (logFileDir != null) {
										sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, logFileDir);
									}									
								}
								else if (propName.equals(AdapterXMLConstants.HyadesGAfileNameAttributeName)) {
									// save property element so it can be set after converter processing
									fileNamePropertyElement = sensorPropertyElement;
									/* There might not be a log file if the converter command generates a file.
									 * If there is a log file then set the fileName property
									 */
									if (logFileName != null) {
										sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, logFileName);
									}									
								}
								else if (propName.equals(AdapterXMLConstants.HyadesGAconverterCmdAttributeName)) {
									if (propValue != null && propValue.length() > 0) {
										if (newConverterCmd == null) {
											newConverterCmd = modifyConverter(propValue, configFileDirectory, table, logFile);
											// ensure the new converter command is not null
											if (newConverterCmd == null) {
												newConverterCmd = "";
											}
										}
										sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, newConverterCmd);
									}
								}
								else {
									propValue = (String)table.get(propName);
									if(propValue != null)
									{
										sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, propValue.trim());
									   if (newConverterCmd == null) {
									   		newConverterCmd = "";
									   }
									}
									sensorTypeAttribute.setNodeValue(newConverterCmd);
								}
							}
							// Process the sensor type instance
							else if (sensorNode.getTagName().equals(AdapterXMLConstants.HyadesGAStaticParserSensorTagName) ||
									 sensorNode.getTagName().equals(AdapterXMLConstants.HyadesGASingleFileSensorTagName)) {
								sensorTypeInstance = sensorNode;
								// Get the sensor properties for this sensor type instance
								NodeList sensorPropertyList = sensorTypeInstance.getElementsByTagName(AdapterXMLConstants.HyadesGASensorPropertyElementTagName);
								int sensorPropertyCount = sensorPropertyList.getLength();
								for(int j = 0; j < sensorPropertyCount; ++j)
								{
									sensorPropertyElement = (Element) sensorPropertyList.item(j);
									propName = sensorPropertyElement.getAttribute(AdapterXMLConstants.HyadesGASensorPropertyNameAttributeName);
									propValue = (String)table.get(propName);
									if(propValue != null)
									{
										sensorPropertyElement.setAttribute(AdapterXMLConstants.HyadesGASensorPropertyValueAttributeName, propValue.trim());
									}
								}

								// Get the sensor type attributes
								NamedNodeMap sensorTypeAttributeList = sensorTypeInstance.getAttributes();
								int sensorTypeAttributeCount = sensorTypeAttributeList.getLength();
					
								for(int j = 0; j < sensorTypeAttributeCount; ++j)
								{
									Node sensorTypeAttribute = sensorTypeAttributeList.item(j);
									String attrName = sensorTypeAttribute.getNodeName();
									// Modify the attribute based on user input
									if(attrName.equals(AdapterXMLConstants.HyadesGAdirectoryAttributeName))
									{
										/* There might not be a log file if the converter command generates a file.
										 * If there is a log file then set the directory attribute
										 */
										if (logFileDir != null) {
											sensorTypeAttribute.setNodeValue(logFileDir);
										}									
									}
									else if(attrName.equals(AdapterXMLConstants.HyadesGAfileNameAttributeName))
									{
										/* There might not be a log file if the converter command generates a file.
										 * If there is a log file then set the fileName attribute
										 */
										if (logFileName != null) {
											sensorTypeAttribute.setNodeValue(logFileName);
										}
									}
									else if(attrName.equals(AdapterXMLConstants.HyadesGAconverterCmdAttributeName))
									{
										if (newConverterCmd == null) {
										   newConverterCmd = modifyConverter(sensorTypeAttribute.getNodeValue(), configFileDirectory, table, logFile);
										   // ensure the new converter command is not null
										   if (newConverterCmd == null) {
										   		newConverterCmd = "";
										   }
										}
										sensorTypeAttribute.setNodeValue(newConverterCmd);
									}
									else
									{
										propValue = (String)table.get(attrName);
										if(propValue != null)
										{
											sensorTypeAttribute.setNodeValue(propValue.trim());
										}
									}
								}
							}
						}
					}
				}

					// Get the sensor attributes
					NamedNodeMap sensorAttributeList = sensorElement.getAttributes();
					int sensorTypeAttributeCount = sensorAttributeList.getLength();
					
					for(int k = 0; k < sensorTypeAttributeCount; ++k)
				{
					Node sensorTypeAttribute = sensorAttributeList.item(k);
					String attrName = sensorTypeAttribute.getNodeName();
					
					// Modify the attribute based on user input
					propValue = (String)table.get(attrName);
					if(propValue != null && propValue.length() > 0)
					{
						Node sensorTypeAttribute = sensorAttributeList.item(k);
						String attrName = sensorTypeAttribute.getNodeName();
						
						// Modify the attribute based on user input
						propValue = (String)table.get(attrName);
						if(propValue != null && propValue.length() > 0)
						{
							sensorTypeAttribute.setNodeValue(propValue.trim());
						}
					}
				}

					// Check if the directory of the log file to be parsed was updated by modifyConverter 				
					if (newDirectory != null) {
						// If so update it in the config file
						if (directoryPropertyElement != null) {
							directoryPropertyElement.setAttribute(AdapterXMLConstants.HyadesGASensorPropertyValueAttributeName, newDirectory);
						}
						if (sensorTypeInstance != null) {
							// Set the attribute
							Node sensorAttribute = sensorTypeInstance.getAttributeNode(AdapterXMLConstants.HyadesGAdirectoryAttributeName);
							sensorAttribute.setNodeValue(newDirectory);					
						}
					}
					
					// Check if the name of the log file to be parsed was updated by modifyConverter 				
					if (newFileName != null) {
						// If so update it in the config file
						if (fileNamePropertyElement != null) {
							fileNamePropertyElement.setAttribute(AdapterXMLConstants.HyadesGASensorPropertyValueAttributeName, newFileName);
						}
						if (sensorTypeInstance != null) {
							// Set the attribute
							Node sensorAttribute = sensorTypeInstance.getAttributeNode(AdapterXMLConstants.HyadesGAfileNameAttributeName);
							sensorAttribute.setNodeValue(newFileName);					
						}	
					}					
				}
				// Else set the properties of the non-sensor components
				else {
					// Get the property children of the component
					NodeList compProperties = compElement.getElementsByTagName(AdapterXMLConstants.HyadesGAPropertyElementTagName);
					for (int k = 0; k < compProperties.getLength(); k++) {
						propertyElement = (Element) compProperties.item(k);
						// Set the property's value to the value of the corresponding parameter in the input hash table						
						propName = propertyElement.getAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName);
						propValue = (String)table.get(propName);
						if(propValue != null)
						{
							System.out.println("Set property " + propName + " with value " + propValue);
							propertyElement.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, propValue.trim());
						}
					}
				}
			}
		}




/**********************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others.
 * 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
 * $Id: GLALoggerFactory.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.provisional.importer;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogConfigurationException;
import org.eclipse.hyades.logging.commons.LoggerFactory;

/**
 * This class extends org.eclipse.hyades.logging.commons.LoggerFactory
 * to instantiate the org.eclpise.hyades.logging.parsers.GLALogger class.
 * 
 * @see org.apache.commons.logging.LogFactory
 * @see org.eclipse.hyades.logging.commons.Logger
 * @see org.eclipse.hyades.logging.commons.LoggerFactory
 * @see org.eclipse.hyades.logging.parsers.provisional.importer.GLALogger
 */
public class GLALoggerFactory extends LoggerFactory {

    /**
     * No-argument constructor.
     */
    public GLALoggerFactory() {
        super();
    }

    /**
     * Returns an instance of a non-null named
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code> based on the
     * parameter name.
     * <p>
     * Passing a <code>null</code> logger name results in a <code>null</code>
     * return value.
     * <p>
     * An instance of a named
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code> is created if no
     * named instance current exists or all instances have been released.
     * <p>
     * Once a named <code>org.eclipse.hyades.logging.parsers.GLALogger</code> is
     * created, the instance is cached for future calls to retrieve the same
     * named <code>org.eclipse.hyades.logging.parsers.GLALogger</code>.
     * <p>
     * The name of the <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     * uniquely identifies an instance of an
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code>. All subsequent
     * calls will return the same instance of the named
     * <code>org.eclipse.hyades.logging.parsers.GLALogger</code>.
     * <p>
     * 
     * @param loggerName
     *            The non-null name of the returned
     *            <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     *            instance.
     * @return A named <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     *         instance, otherwise <code>null</code> if the parameter logger
     *         name is <code>null</code>.
     * @exception LogConfigurationException
     *                if the named
     *                <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
     *                instance could not be created.
     * @see org.apache.commons.logging.LogFactory#getInstance(java.lang.String)
     */
    public Log getInstance(String loggerName) throws LogConfigurationException {

        if (loggerName != null) {

            if (loggers.containsKey(loggerName)) { return (((Log) (loggers.get(loggerName)))); }

            GLALogger logger = new GLALogger(loggerName);

            loggers.put(loggerName, logger);

            return logger;
        }

        return null;
    }
}




/**********************************************************************
 * Copyright (c) 2006,2008 IBM Corporation and others.
 * 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
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 * Change History:
 **********************************************************************/
package org.eclipse.hyades.logging.parsers.provisional.importer;

import java.util.Hashtable;

import org.apache.commons.logging.Log;
import org.eclipse.hyades.loaders.util.XMLLoader;
import org.eclipse.hyades.logging.parsers.LogParserException;
import org.eclipse.hyades.logging.parsers.importer.ILogParser;

/**
 * 
 * This is a specialized logger to be used by GLA for local log imports.  It is
 * instantiated by clients and passed to GLA via ParserWrapper.parse(Log) method.
 * Currently it is available internally only for use by the Log Import Wizard in
 * org.eclipse.tptp.monitoring.logui
 * 
 * @author Cindy Jin
 *
 */
public class LocalLogImportLoader  implements Log {


    protected Hashtable parserParameters = null;
    protected ILogParser parser = null;
    protected XMLLoader xmlLoader = null;
    protected Log logParser = null;
    protected boolean traceXML = false;

    /**
	 * Trace logging level value.
	 */
	public static final int TRACE_LEVEL = 0;

	/**
	 * Debug logging level value.
	 */
	public static final int DEBUG_LEVEL = 1;

	/**
	 * Information logging level value.
	 */
	public static final int INFO_LEVEL = 2;

	/**
	 * Warning logging level value.
	 */
	public static final int WARN_LEVEL = 3;

	/**
	 * Error logging level value.
	 */
	public static final int ERROR_LEVEL = 4;

	/**
	 * Fatal logging level value.
	 */
	public static final int FATAL_LEVEL = 5;

	/**
	 * The logger's current logging level value.
	 */
	protected int loggingLevel;
	public LocalLogImportLoader()
	{
		parser           = null;
		parserParameters = null;
	}

    public LocalLogImportLoader(ILogParser parser, Hashtable parserParameters, boolean traceXML) {
        this.parser = parser;
        this.parserParameters = parserParameters;
        this.traceXML = traceXML;
    }

    public void setXMLLoader(XMLLoader xmlLoader) {
    	 parserParameters.put("xmlLoader", xmlLoader);
        this.xmlLoader = xmlLoader;
    }
    
     
    public void startParsing() throws LogParserException {
        parser.setUserInput(parserParameters);
        parser.parse(this);
    }
    public void setParserLogger(Log logParser){
    	this.logParser = logParser;
    	parser.setParserLogger(logParser); 
    }
    
    public Log getParserLogger(){
    	return logParser;
    }

    public XMLLoader getXMLLoader()
    {
    	return xmlLoader;
    }
    
	public boolean isTraceEnabled() {
		return (loggingLevel<=TRACE_LEVEL);
	}

	public boolean isDebugEnabled() {
		return (loggingLevel<=DEBUG_LEVEL);
	}


	public boolean isInfoEnabled() {
		return (loggingLevel<=INFO_LEVEL);
	}

	public boolean isWarnEnabled() {
		return (loggingLevel<=WARN_LEVEL);
	}

	public boolean isErrorEnabled() {
		return (loggingLevel<=ERROR_LEVEL);
	}

	public boolean isFatalEnabled() {
		return (loggingLevel<=FATAL_LEVEL);
	}

	 
	public void trace(Object record) {
	}

	public void trace(Object record, Throwable throwable) {
	}

	public void debug(Object record) {
	}

	public void debug(Object record, Throwable throwable) {
	}

	public void info(Object record) {
	}

	public void info(Object record, Throwable throwable) {
	}


	public void warn(Object record) {
	}

	public void warn(Object record, Throwable throwable) {
	}

	public void error(Object record) {
	}

	public void error(Object record, Throwable throwable) {
	}


	public void fatal(Object record) {

	}


	public void fatal(Object record, Throwable throwable) {

	}
	
	
}




/**********************************************************************
 * Copyright (c) 2006,2008 IBM Corporation and others.
 * 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
 * $Id: LocalGLALogger.java,v 1.2 2006/09/20 19:20:23 dnsmith Exp $
 *
 * Contributors:
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.provisional.importer;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.eclipse.hyades.logging.events.cbe.CommonBaseEvent;

public class LocalGLALogger implements Log {

	//private XmlGenerator xmlGenerator = new XmlGenerator();
	private List events = new ArrayList();
	private  final String NL = System.getProperties().getProperty("line.separator");
	
	private String detailMessage = null;

	/**
	 * Trace logging level value.
	 */
	public static final int TRACE_LEVEL = 0;

	/**
	 * Debug logging level value.
	 */
	public static final int DEBUG_LEVEL = 1;

	/**
	 * Information logging level value.
	 */
	public static final int INFO_LEVEL = 2;

	/**
	 * Warning logging level value.
	 */
	public static final int WARN_LEVEL = 3;

	/**
	 * Error logging level value.
	 */
	public static final int ERROR_LEVEL = 4;

	/**
	 * Fatal logging level value.
	 */
	public static final int FATAL_LEVEL = 5;

	/**
	 * The logger's current logging level value.
	 */
	private int loggingLevel;

	public LocalGLALogger() {
		//xmlGenerator.reset(null, true, 8);
		loggingLevel = 0;
	}

	public String getLogDetails() {
		StringBuffer buffer = new StringBuffer();
		synchronized(events){
			int s = events.size();
			String msg = null;
			if(s>0){
				for(int i=0;i<s-1;i++){
					msg = (String)events.get(i);
					if(msg!=null){
						buffer.append(msg);				
						buffer.append(NL);
					}			
				}
				msg = (String)events.get(s-1);
				if(msg!=null){
					buffer.append(msg);
				}
			}
		}
		detailMessage = buffer.toString();
		return detailMessage;
	}

	public boolean isDebugEnabled() {
		return (loggingLevel <= DEBUG_LEVEL);
	}

	public boolean isErrorEnabled() {
		return (loggingLevel <= ERROR_LEVEL);
	}

	public boolean isFatalEnabled() {
		return (loggingLevel <= FATAL_LEVEL);
	}

	public boolean isInfoEnabled() {
		return (loggingLevel <= INFO_LEVEL);
	}

	public boolean isTraceEnabled() {
		return (loggingLevel <= TRACE_LEVEL);
	}

	public boolean isWarnEnabled() {
		return (loggingLevel <= WARN_LEVEL);
	}

	public void trace(Object record) {
		if (isTraceEnabled()) {
			synchronized(events){
				if(record!=null && record instanceof CommonBaseEvent)
				if(((CommonBaseEvent)record).getMsg()!=null && !events.contains(((CommonBaseEvent)record).getMsg())){
					events.add(((CommonBaseEvent)record).getMsg());
				}
			}
//			this.detailMessage = xmlGenerator.objectToXML(record);
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void trace(Object record, Throwable arg1) {
		if (isTraceEnabled()) {
			trace(record);
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void debug(Object record) {
		if (isDebugEnabled()) {
			trace(record);
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void debug(Object record, Throwable arg1) {
		if (isDebugEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void info(Object record) {
		if (isInfoEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void info(Object record, Throwable arg1) {
		if (isInfoEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void warn(Object record) {
		if (isWarnEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}

	}

	public void warn(Object record, Throwable arg1) {
		if (isWarnEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void error(Object record) {
		if (isErrorEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void error(Object record, Throwable arg1) {
		if (isErrorEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void fatal(Object record) {
		if (isFatalEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

	public void fatal(Object record, Throwable arg1) {
		if (isFatalEnabled()) {
//			logXMLToModel(xmlGenerator.objectToXML(record));
		}
	}

}




/**********************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others.
 * 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
 * $Id: StatusMonitor.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/
package org.eclipse.hyades.logging.parsers.provisional.importer;

import org.apache.commons.logging.Log;

/**
 * This class is a runnable that checks the status of a log parser
 * at regular intervals and sends the status to a logging agent.
 */
public class StatusMonitor implements Runnable {

	// Class of the parser object
	private Class parserClass = null;
	
	// The parser object
	private Object parser = null;
	
	// The logging agent to write the status to.
	private Log statusLogger = null;
	
	/**
	 * Constructor with required parameters
	 * @param parser object that is doing the log parsing
	 * @param parserClass class of the parser object
	 * @param statusLogger logging agent to write the status to
	 */
	public StatusMonitor(Object parser, Class parserClass, Log statusLogger) {
		super();
		
		this.parser = parser;
		this.parserClass = parserClass;
		this.statusLogger = statusLogger;
	}

	/**
	 * Run this StatusMonitor thread.
	 * @see java.lang.Runnable#run()
	 */
	public void run() {
		String status = null;
		
		// Status checking loop.
		while (true) {
			try {
				// Get the status of the parsing object.
				status = (String)parserClass.getMethod("getStatus",null).invoke(parser, null);
			}
			catch (Exception e) {
				System.err.println("Exception occured when getting status: " + e.getMessage());
				status = null;
			}
			// write status string to status agent
			if (status != null) {
				statusLogger.trace(status);
			}
			
			// If this thread has been interrupted then quit the monitoring loop.
			if (Thread.interrupted()) {
				break;
			}
			
	   		/* Sleep for 2 seconds before checking the status again.
    		 * The parsing thread may interrupt this thread to indicate it is done so break
    		 * from the monitoring loop.
    		 */
            try {
            	Thread.sleep(2000);
            }
            catch (InterruptedException e) {
            	// Quit the monitoring loop if this thread has been interrupted
            	break;
            }
		}

	}

}




/**********************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others.
 * 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
 * $Id
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.provisional.importer;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import org.eclipse.hyades.logging.adapter.impl.AdapterXMLConstants;
import org.eclipse.hyades.logging.adapter.util.AdapterConstants;
import org.eclipse.hyades.logging.adapter.util.Messages;
import org.eclipse.hyades.logging.parsers.LogParserException;
import org.eclipse.hyades.logging.parsers.ParserConstants;
import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;

/**
 * Helper class for finding the GLA adapter configuration file.
 * 
 * @author apnan
 *
 */
public class GLAHelper {

	protected static short platform = -1;//flag indicating whether the code runs in the workbench or outside the workbench
										// the values that this flag can have are:
										// -1: GLAHelper wasn't initialized
										// 0: GLAHelper runs outside the workbench
										// 1: GLAHelper runs in the workbench
	
	/**
	 * Get the adapter configuration file path.
	 * @param table the parser parameters hash stable
	 * @param nameSpace the plugin name if running in the workbench, null otherwise
	 * @param useOriginalAdapter boolean to indicate to use the original adapter file specification
	 * stored in the hash table with key originalAdapter
	 * @return the adapter file path. 
	 * @throws LogParserException
	 */
	public static synchronized String getAdapterPath(Map table, String nameSpace, boolean useOriginalAdapter) throws LogParserException{
		
		String key; 
		
		if (useOriginalAdapter) {
			key = LogParserConstants.ORIGINAL_ADAPTER_KEY;
		}
		else {
			key = getAdapterPathKey(table);
			if(key==null){
				String message = Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", (String)null); 
				throw new LogParserException(message);
			}
			if(GLADebug.INSTANCE.debug){
				GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: adapter key="+key);			
			}
		}
		
		String config_file = (String)table.get(key);

		//get the adapter config file path
		String adapterFilePath = "";
		
		if(config_file.indexOf("./")>-1){
			config_file = config_file.substring(2);			
		}
		
		/* If running in an eclipse workbench environment then try to get the adapter file
		 * path based on the plugin bundle.
		 */
		if(isWorkbenchMode()){
			try {
				// Bundle bundle = Platform.getBundle(nameSpace);
				Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
	            Method getBundle = platformClass.getMethod("getBundle", new Class[]{String.class});
	            Object bundle = getBundle.invoke(null, new String[]{nameSpace});
	            Class pathClass = Class.forName("org.eclipse.core.runtime.IPath");
	            Class bundleClass = Class.forName("org.osgi.framework.Bundle");
	            Method find = platformClass.getMethod("find", new Class[]{bundleClass, pathClass});
				
				if(bundle!=null){
					//verify if the adapter is NL enabled
					if(config_file.indexOf("/nl/")>-1){
						config_file = getNLAdapterPath(table, config_file, find, bundle);
						if(config_file==null){
							String message = Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", (String)table.get(key)); 
							throw new Exception(message);
						}
						adapterFilePath = config_file; 
					}else{				
						URL fileURL = find(find, bundle, config_file);
						if(fileURL==null){
							//config_file = "config/"+config_file;
							fileURL = find(find, bundle, "config/"+config_file);
						}
						if(fileURL!=null){
							adapterFilePath = fileURL.toString();
						}else{
							/* Try using the config file root from the hash table if Log Import Wizard modified the
							 * adapter with a filter. */
							adapterFilePath = (String) table.get(LogParserConstants.CONFIG_FILE_ROOT_KEY) + "/" + config_file;			
							File test = new File(adapterFilePath);
							if(!test.exists()){
								// Couldn't find adapter file so throw an exception
								throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", config_file));
							}
						}
					}
				}else{
					adapterFilePath = config_file; 
				}
			}
			catch (Throwable e) {
				// Capture the exception in a LogParserException
				throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", config_file),e);
			}
			
		}
		/* Else find the adapter file path based on path variables in the hash table */
		else{
			
			//verify if the adapter is NL enabled
			if(config_file.indexOf("/nl/")>-1){
				if(GLADebug.INSTANCE.debug){
					GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: trying to get the nl adapter file using base file "+config_file);			
				}
				config_file = getNLAdapterPath(table, config_file, null, null);
				if(config_file==null){
					String message = Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", (String)table.get(key)); 
					throw new LogParserException(message);
				}
				adapterFilePath = config_file; 
			}else{
				String adapterPath = (String)table.get(LogParserConstants.CONFIG_FILE_ROOT_KEY) ;
				
//				//check to see if the global properties are set
//				if (adapterPath == null){
//					adapterPath = CBEConfigurationProperties.instance().getProperties().getProperty(CBEConfigurationProperties.ADAPTER_LOCATION);
//				}
				adapterFilePath = adapterPath + "/" + config_file;
				if(GLADebug.INSTANCE.debug){
					GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: try to find the adapter file using ConfigFileRoot path eg. "+adapterFilePath);			
				}
				File test = new File(adapterFilePath);
				if(!test.exists()){
					adapterFilePath = adapterPath + "config/"+config_file;
					if(GLADebug.INSTANCE.debug){
						GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: try to find the adapter file using ConfigFileRoot path plus config eg. "+adapterFilePath);			
					}
					test = new File(adapterFilePath);
					if(!test.exists()){
						// last attempt 
						//
						// Bug 62317
						// Try to resolve the config file using the command line list of directories
						//
						String config_paths = (String)table.get(LogParserConstants.CONFIG_PATH_KEY); // get the paths containing the adapter files

						// Check to ensure config_path was set in the input table
						// If it is not then throw an appropriate exception.
						if (config_paths != null && config_paths.length() != 0) {
							StringTokenizer strtok = new StringTokenizer(config_paths, File.pathSeparator, false); // tokenize the path
							while(strtok.hasMoreTokens()) {
								String config_path = strtok.nextToken();

								if(GLADebug.INSTANCE.debug){
									GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: try to find the adapter file " + config_file + " using config_path "+config_path);			
								}
								File f = new File(config_path, config_file); // look for the adapter file using the path
								if(f.exists()) {									
//									table.remove(LogParserConstants.CONFIG_PATH_KEY); // This is no longer required									
									adapterFilePath = f.getAbsolutePath();
									return adapterFilePath;
								}
							}
						}
						// Bug 62317 ends

						if(GLADebug.INSTANCE.debug){
							GLADebug.INSTANCE.log("GLAHelper.getAdapterPath: could not find the adapter file!  Throwing an exception.");			
						}
						throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", config_file));
						
					}
				}			
			}
		}		
		return adapterFilePath;		
	}
	/**
	 * Initializes the context in which this class is running.
	 * Determines whether the code runs in a workbench context or outside. 
	 * Calling this method is required before using the adapter path helper method.
	 *
	 */
	protected static synchronized void initialize(){
		try {
            Class resourcePlugin = Class.forName("org.eclipse.core.resources.ResourcesPlugin");
            Method getWorkspace = resourcePlugin.getMethod("getWorkspace", null);
            Object workspace = getWorkspace.invoke(null, null);
            Method getRoot = workspace.getClass().getMethod("getRoot", null);
            Object root = getRoot.invoke(workspace, null);

            platform =(short)((root != null) ? 1 : 0);
        } catch (ClassNotFoundException e) {
        	platform = 0;
        } catch (SecurityException e) {
        	platform = 0;
        } catch (NoSuchMethodException e) {
        	platform = 0;
        } catch (IllegalArgumentException e) {
        	platform = 0;
        } catch (IllegalAccessException e) {
        	platform = 0;
        } catch (InvocationTargetException e) {
        	platform = 0;
        } catch (NullPointerException e) {
        	platform = 0;
        }
	}

	/**
	 * Get the absolute path of the adapter configuration file.
	 * @param table the parser parameters hash stable
	 * @param nameSpace the plugin name if running in the workbench, null otherwise
	 * @param useOriginalAdapter boolean to indicate to use the original adapter file specification
	 * stored in the hash table with key originalAdapter
	 * @return the absolute path of the adapter file. 
	 * @throws LogParserException
	 */
	public static synchronized String getAbsoluteAdapterPath(Map table, String nameSpace, boolean useOriginalAdapter) throws LogParserException{
		String adapterPath = getAdapterPath(table, nameSpace, useOriginalAdapter);
		
		/* If running in eclipse workbench environment Then the adapter path returned by getAdapterPath may
		 * be a URL based on the plugin bundle.  In that case it needs to be converted to an
		 * absolute file path.
		 */
		if(isWorkbenchMode()){
			try{
				Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
	            Method asLocalURL = platformClass.getMethod("asLocalURL", new Class[]{URL.class});
	            URL adapterURL = new URL(adapterPath);
	            URL absoluteURL = (URL)asLocalURL.invoke(null, new Object[]{adapterURL});
	            return absoluteURL.getFile();
			}catch (MalformedURLException ue) {
				/* Assume that the path returned by getAdapterPath is not a URL but is already an absolute path for
				 * the adapter file.  Iit will be returned.
				 */
			}catch (Throwable e) {
				// Capture the exception in a LogParserException
				throw new LogParserException(Messages.getString("HyadesGA_CBE_Adapter_No_Config_File_ERROR_", adapterPath),e);
			}

			
		}
		return adapterPath;
	}
	/**
	 * Get the key that is used to find the adapter configuration file name in the hash table.
	 * @param table the parser parameters hash table
	 * @return the hash table key corresponding to the adapter file path, null if no adapter
	 * file path found.
	 */
	public static synchronized String getAdapterPathKey(Map table){
		String key = null;
		String version = (String) (table.get(ParserConstants.APPLICATION_VERSION_KEY));
		String config_file = null;
		
		// If no version attribute given, use default
		if(version == null)
		{
			version = LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY;
		}

		// Get the config file defined for this version
		config_file =  (String) (table.get(version));
		
		if(config_file == null && version != LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY)
		{
			// Cannot find the corresponding config file, use default
			config_file = (String) (table.get(LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY));
			
			// If the default file is the desired adapter file then set the key to return 
			if(config_file != null) { 
				key = LogParserConstants.DEFAULT_APPLICATION_VERSION_KEY;
			}			
		}
		else if (config_file != null) {
			key = version;
		}

		return key;
	
	}
	
	/**
	 * 
	 * @return boolean whether object is executing in an Eclipse workbench environment
	 */
	public static synchronized boolean isWorkbenchMode(){
		if(platform==-1){
			initialize();
		}
		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("workbench="+platform);			
		}
		
		return platform ==1;
	}
	
	/**
	 * Get the adapter configuration file path based on locale and encoding.
	 * @param table Hash table of input parameters
	 * @param configFilePath The adapter configuration file to find.
	 * @param find The method to find the file
	 * @param bundle - plugin bundle
	 * @return the adapter configuration file path
	 */
	protected static synchronized String getNLAdapterPath(Map table,
			String configFilePath, Method find, Object bundle){

		String characterEncoding = (String) table
				.get(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_CHARACTER_ENCODING);
		String countryCode = (String) table
				.get(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_ISO_COUNTRY_CODE);
		String languageCode = (String) table
				.get(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_ISO_LANGUAGE_CODE);

		String locale = null;
		/*
		 * bugzilla 135799
		 * Get the default system locale and character encoding if the default string is 
		 * passed in.
		 */
		if (languageCode != null && languageCode.equals(AdapterConstants.AttributeValue_Default)) {
			languageCode = Locale.getDefault().getLanguage();
		}
		if (countryCode != null && countryCode.equals(AdapterConstants.AttributeValue_Default)) {
			countryCode = Locale.getDefault().getCountry();
		}

		if (characterEncoding != null && characterEncoding.equals(AdapterConstants.AttributeValue_Default)) {
			try {
				characterEncoding = System.getProperty("file.encoding");
			}
			catch (SecurityException e) {
				/* null file encoding will be handled below */
			}
		}
		if(countryCode!=null && countryCode.length() == 0){
			locale = languageCode;
		}else if(countryCode!=null && languageCode!=null){
			locale = languageCode + "_" + countryCode;
		}

		int i = configFilePath.indexOf("/nl/");
		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("characterEncoding="+characterEncoding);
			GLADebug.INSTANCE.log("countryCode="+countryCode);
			GLADebug.INSTANCE.log("languageCode="+languageCode);
		}
		
		// try to find the adapter in the following order
		// <root>/nl/<ISOLanguageCode>_<ISOCountryCode>/<characterEncoding>
		// <root>/nl/<ISOLanguageCode>_<ISOCountryCode>
		// <root>/nl/<characterEncoding>
		// <root>/nl/
		
		String[][] searchPath = new String[][]{{locale, characterEncoding}, {locale}, {characterEncoding}, {"/"}};
		if (i < 0) {
			return configFilePath;
		}
		int j = configFilePath.lastIndexOf('/');
		String dir = configFilePath.substring(0, i + 3);
		String fileName = configFilePath.substring(j);
		
		StringBuffer path = new StringBuffer();
		String[] currentPath = null;
		int l = 0;

		String fullPath = null;
		String lastPathAppended = null;
		for(int idx=0;idx<4 && fullPath==null;idx++){
			currentPath = searchPath[idx];
			l = currentPath.length;
			path.append(dir);
			for(int jdx=0;jdx<l;jdx++){				
				if(currentPath[jdx]==null){
					continue;
				}
				if(!currentPath[jdx].equals("/")){
					path.append('/');
				}
				path.append(currentPath[jdx]);
				lastPathAppended = currentPath[jdx];
			}
			if(lastPathAppended!=null && lastPathAppended.equals("/")){
				path.append(fileName.substring(1));
			}else{
				path.append(fileName);
			}
			fullPath = getPath(table, find, bundle, path.toString());
			path.setLength(0);
		}

		return fullPath;
	}
	
	/**
	 * Get the full path of the adapter configuration file
	 * @param table Hash table of input parameters
	 * @param find The method to use to find the URL
	 * @param bundle The plugin bundle
	 * @param configFilePath
	 * @return the full path of the adapter file
	 */
	protected static synchronized String getPath(Map table, Method find, Object bundle, String configFilePath){
		String filePath = null;
		if(bundle!=null){
			// workbench context mode: local import
			URL fileURL = find(find, bundle, configFilePath);
			if(fileURL==null){
				fileURL = find(find, bundle, "config/"+configFilePath);
			}
			if (fileURL != null) {
				filePath = fileURL.toString();
			}
		}else{
			// outside workbench context: remote import or web client
			String adapterPath = (String)table.get(LogParserConstants.CONFIG_FILE_ROOT_KEY) ;
			
//			//check to see if the global properties are set
//			if (adapterPath == null){
//				adapterPath = CBEConfigurationProperties.instance().getProperties().getProperty(CBEConfigurationProperties.ADAPTER_LOCATION);
//			}
			
			String adapterFilePath = adapterPath + "/" + configFilePath;
			File file = new File(adapterFilePath);
			if(file.exists()){
				filePath = adapterFilePath;
			}else {
				String config_paths = (String)table.get(LogParserConstants.CONFIG_PATH_KEY); // get the paths containing the adapter files
				if (config_paths != null && config_paths.length() != 0) {
					StringTokenizer strtok = new StringTokenizer(config_paths, File.pathSeparator, false); // tokenize the path
					while(strtok.hasMoreTokens()) {
						String config_path = strtok.nextToken();

						File f = new File(config_path, configFilePath); // look for the adapter file using the path
						if(f.exists()) {
							filePath = f.getAbsolutePath();
						}
					}
				}	
			}		
		}
		if(GLADebug.INSTANCE.debug){
			GLADebug.INSTANCE.log("GLAHelper.getPath: Attempted to get adapter at path "+configFilePath +" result: file=" +filePath);
		}

		return filePath;
	}
	
	/**
	 * Find the URL of the adapter configuration file
	 * @param find The method to find the adapter file
	 * @param bundle - The plugin bundle
	 * @param config_file - the adapter configuration file to find
	 * @return the URL of the adapter configuration file
	 */
	protected static URL find(Method find, Object bundle, String config_file){
		URL fileURL = null;
		Class pathClass;
		try {
			pathClass = Class.forName("org.eclipse.core.runtime.Path");
			Constructor pathConstructor = pathClass.getConstructor(new Class[] {config_file.getClass()});
			Object path = pathConstructor.newInstance(new Object[] {config_file});
			fileURL = (URL)find.invoke(null, new Object[]{bundle, path});
			
		} catch (Exception e) {			
			if(GLADebug.INSTANCE.debug)
				e.printStackTrace();
		}
		return fileURL;
		
	}
	
}




/**********************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others.
 * 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
 * $Id: GLALogger.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

package org.eclipse.hyades.logging.parsers.provisional.importer;

import org.eclipse.hyades.logging.commons.Logger;
import org.eclipse.hyades.logging.events.cbe.CommonBaseEvent;

/**
 * This class extends org.eclipse.hyades.logging.commons.Logger
 * so that it only logs the Common Base Event message instead of the
 * whole Common Base Event.  This class is used to log GLA messages.
 * 
 * @see org.apache.commons.logging.Log
 * @see org.apache.commons.logging.LogFactory
 * @see org.eclipse.hyades.logging.core.LoggingAgent
 * @see org.eclipse.hyades.logging.commons.Logger
 * @see org.eclipse.hyades.logging.commons.LoggerFactory
 */
public class GLALogger extends Logger {

    /**
     * Constructor to create a logger instance with a Logging Agent using the
     * parameter name.
     * 
     * NOTE: The default logging level is set to WARN until explicitly set.
     * 
     * @param name
     *            The name of the newly created logger.
     */
    public GLALogger(String name) {

        super(name);
 
    }

    /**
     * Logs the parameter <code>java.lang.Object</code> log record to the
     * Logging Agent with the same name as the logger if TRACE logging is
     * currently enabled.
     * 
     * If the log record is a CommonBaseEvent only the CommonBaseEvent message will be 
     * sent to the Logging Agent.  Otherwise it is assumed the record is a String.
     * 
     * @param record
     *            The log record to be logged to the Logging Agent.
     */
    public void trace(Object record) {

        if (isTraceEnabled()) {
        	if (record instanceof CommonBaseEvent) {
        		loggingAgent.write("glalog=" + ((CommonBaseEvent)record).getMsg());
        	}
        	else if (record instanceof String) {
        		loggingAgent.write((String)record);
        	}
        }
    }

    /**
     * Logs the parameter <code>java.lang.Object</code> log record and
     * <code>java.lang.Throwable</code> exception to the Logging Agent with
     * the same name as the logger if TRACE logging is currently enabled.
     * 
     * If the log record is a CommonBaseEvent only the CommonBaseEvent message will be 
     * sent to the Logging Agent.  Otherwise it is assumed the record is a String.
     * 
     * Only the parameter <code>java.lang.Object</code> log record is logged.
     * The <code>java.lang.Throwable</code> exception is ignored.
     * 
     * @param record
     *            The log record to be logged to the Logging Agent.
     * @param throwable
     *            The exception will be ignored
     */
    public void trace(Object record, Throwable throwable) {

        if (isTraceEnabled()) {
           	if (record instanceof CommonBaseEvent) {
        		loggingAgent.write("glalog=" + ((CommonBaseEvent)record).getMsg());
        	}
        	else if (record instanceof String) {
        		loggingAgent.write((String)record);
        	}
        }
    }

}




/*******************************************************************************
 * Copyright (c) 2005,2008 IBM Corporation and others. 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
 * $Id
 * 
 * Contributors: IBM - Initial API and implementation
 ******************************************************************************/

package org.eclipse.hyades.logging.parsers.provisional.importer;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * This class provides debugging facilities for the Log Import code.
 * 
 * @author apnan
 *
 */
public class GLADebug {

	public boolean debug = false;
	public boolean logToFile = false;
	
	protected String plugin_name; 
	protected String value;
	protected final String NL = System.getProperties().getProperty("line.separator");
	private FileOutputStream log = null;

	public static GLADebug INSTANCE = new GLADebug("org.eclipse.hyades.logging.parsers");

	public GLADebug(String plugin_name) {
		this.plugin_name = plugin_name;
		init();
	}

	/**
	 * Initialize the debugging code.
	 *
	 */
	protected void init() {
		try {
			// Get the debugging options from the options file.		
			Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
            Method getDebugOption = platformClass.getMethod("getDebugOption", new Class[]{String.class});
            value = (String)getDebugOption.invoke(null, new String[]{plugin_name+"/debug"});
			
			if (value != null) {
				debug = value.equalsIgnoreCase("true");
			} else if(System.getProperty("GLADebug.debug")!=null)
			{
					debug = Boolean.valueOf(System.getProperty("GLADebug.debug")).booleanValue();
			}
			value = (String)getDebugOption.invoke(null, new String[]{plugin_name+"/logToFile"});
			if (value != null) {
				logToFile = value.equalsIgnoreCase("true");
			} else if(System.getProperty("GLADebug.logToFile")!=null)
			{
				logToFile = Boolean.valueOf(System.getProperty("GLADebug.logToFile")).booleanValue();
			}
			
			
		} catch (Exception e) {
			//	The platform is not available, read the environment variables
			debug = Boolean.valueOf(System.getProperty("GLADebug.debug")).booleanValue();
			logToFile = Boolean.valueOf(System.getProperty("GLADebug.logToFile")).booleanValue();
		}		
	}
	
	/**
	 * Get the debug log file output stream.
	 * 
	 * @return the FileOutputStream for the debug file
	 */
	public FileOutputStream getLog(){
		if(log==null){
			try {
				log = new FileOutputStream("./GLADebug-"+(new Date()).getTime());
			} catch (FileNotFoundException e) {
				if(debug)
					e.printStackTrace();
			}
		}else{
			if(!log.getChannel().isOpen())
			{
				try {
					log = new FileOutputStream("./GLADebug-"+(new Date()).getTime());					
				} catch (FileNotFoundException e) {
					if(debug)
						e.printStackTrace();
				}
			}
			
		}
		return log;
	}
	
	/**
	 * Log a debug message
	 * @param message
	 */
	public void log(String message){
		if(logToFile){
			// Log the message to the log file.
			try {
				getLog().write(message.getBytes());
				getLog().write(NL.getBytes());
			} catch (IOException e) {			
				if(debug)	
					e.printStackTrace();
			}
		}else{
			// Log the message to System.out
			System.out.println(message);
		}
	}
	
}




/**********************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * 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
 * $Id: LocalLogParserLoader.java,v 1.1 2006/08/23 21:17:51 sleeloy Exp $
 *
 * Contributors:
 * IBM - Initial API and implementation
 **********************************************************************/
package org.eclipse.hyades.logging.parsers.provisional.importer;

import java.io.UnsupportedEncodingException;
import java.util.Hashtable;

import org.apache.commons.logging.Log;
import org.eclipse.hyades.internal.logging.core.Constants;
import org.eclipse.hyades.logging.events.cbe.util.EventFormatter;
import org.eclipse.hyades.logging.events.cbe.util.EventHelpers;
import org.eclipse.hyades.logging.parsers.importer.ILogParser;

public class LocalLogParserLoader extends LocalLogImportLoader{

    //~ Constructors -------------------------------------------------------------------------------

    public LocalLogParserLoader(ILogParser parser, Hashtable parserParameters, boolean traceXML) {
    	super(parser, parserParameters, traceXML);
    	loggingLevel=0;
    }

    //~ Methods ------------------------------------------------------------------------------------

    
    public Log getParserLogger(){
    	return logParser;
    }

    //NOTE: Temporary API to propagate logged raw objects to the model as XML strings:
    private void logXMLToModel(String xml) {
        // Note:  L0DocumentEventHandler (perftrace.loader.XMLLoader) XML scanner MUST be passed UTF8 encoded byte array data:
        byte[] xmlLogEntryBytes = null;

        try {
            xmlLogEntryBytes = xml.getBytes("UTF8");
        }
        catch (UnsupportedEncodingException u) {
            xmlLogEntryBytes = xml.getBytes();
        }

        //		System.err.println(xml);
        xmlLoader.loadEvent(xmlLogEntryBytes, xmlLogEntryBytes.length);
    }
    
	/**
	 * Logs the parameter <code>java.lang.Object</code> log record to the Logging Agent 
	 * with the same name as the logger if TRACE logging is currently enabled.  
	 * 
	 * The log record is first converted to XML and then sent to the Logging Agent.
	 * 
	 * @param record The log record to be logged to the Logging Agent.
	 */

	public void trace(Object record) {
//		try {
			if (isTraceEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void trace(Object record, Throwable throwable) {
//		try {
			if (isTraceEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void debug(Object record) {
//		try {
			if (isDebugEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void debug(Object record, Throwable throwable) {
//		try {
			if (isDebugEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void info(Object record) {
//		try {
			if (isInfoEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}

	}

	public void info(Object record, Throwable throwable) {

//		try {
			if (isInfoEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


	public void warn(Object record) {
//		try {
			if (isWarnEnabled()) {
                if(!traceXML){	
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
                }else{
                	logXMLToModel((String)record);
                }
			}
//		}
//		catch (Throwable t) {
//		}
	}

	public void warn(Object record, Throwable throwable) {
//		try {
			if (isWarnEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}

	public void error(Object record) {
//		try {
			if (isErrorEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}

	public void error(Object record, Throwable throwable) {

//		try {
			if (isErrorEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


	public void fatal(Object record) {
//		try {
			if (isFatalEnabled()) {
				if(!traceXML){
                	logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


	public void fatal(Object record, Throwable throwable) {

//		try {
			if (isFatalEnabled()) {
				if(!traceXML){
					logXMLToModel(EventFormatter.toCanonicalXMLString(EventHelpers.convertObjectToCommonBaseEvent(record,4), true).concat(Constants.LINE_SEPARATOR));
				}else{
					logXMLToModel((String)record);
				}
			}
//		}
//		catch (Throwable t) {
//		}
	}


}
   





/**********************************************************************
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * 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
 * $Id: Controller.java,v 1.9 2007/03/22 05:29:24 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 * Change History:
 * Bugzilla  Description
 * 79014     Improved error handling and message logging
 * 
 **********************************************************************/
package org.eclipse.hyades.logging.adapter.internal.util;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.eclipse.hyades.logging.adapter.AdapterException;
import org.eclipse.hyades.logging.adapter.AdapterInvalidConfig;
import org.eclipse.hyades.logging.adapter.AdapterPlugin;
import org.eclipse.hyades.logging.adapter.IComponent;
import org.eclipse.hyades.logging.adapter.IContext;
import org.eclipse.hyades.logging.adapter.IContextListener;
import org.eclipse.hyades.logging.adapter.IOutputter;
import org.eclipse.hyades.logging.adapter.IProcessUnit;
import org.eclipse.hyades.logging.adapter.impl.AdapterContext;
import org.eclipse.hyades.logging.adapter.impl.AdapterXMLConstants;
import org.eclipse.hyades.logging.adapter.impl.Component;
import org.eclipse.hyades.logging.adapter.impl.Context;
import org.eclipse.hyades.logging.adapter.impl.Status;
import org.eclipse.hyades.logging.adapter.parsers.PreparationException;
import org.eclipse.hyades.logging.adapter.util.AdapterConstants;
import org.eclipse.hyades.logging.adapter.util.AdapterUtilities;
import org.eclipse.hyades.logging.adapter.util.Messages;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
 * Controller manages a set of Context objects by setting the configurations and then starting each context.
 * 
 */
public class Controller implements Runnable {
   
    private boolean singleFileInputMode = false;
    
    /* Keep our contexts and thier associated threads within a list. It is imperative that the index
     *  of each list be kept consistant.  That is, the thread running context at index n must be in the
     *  thread list at index n
     */
    private Context[] contexts;
    private Thread[]   contextThreads;
    
  	// Adapter log outputter component
    private IOutputter logOutputter = null;
    
    private String contextConfigurationFile = AdapterConstants.HyadesGADefaultContextConfigurationFile;
    private String componentConfigurationFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile;
    private DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
    private InputStream inContextParams = null;
    private InputStream inAppParams = null;
    private boolean running = false;
    private long sleepTime = 500;

    // Overall logging level for the Adapter
    private short loggingLevel = -1;
    /**
     * Constructor for Controller.
     */
    public Controller() {
        super();
    }
    
    /**
     * Returns whether the Controller is running.
     * @return true if Controller is running, false otherwise
     */
    public boolean isRunning() {
        return running;
    }
    
    /**
     * Start running the controller which means starting up each of the contexts.
     */
    public void start() {
    	/* RKD:  We will run all of the contexts except the first one 
    	 * (our internal logging context), each in its own thread.
    	 * The internal logging context was already started
    	 * when we went through the prepare stage.
         */
    	synchronized(contexts) {
	        for (int i = 1; i < contextThreads.length; ++i) {
	            if (contexts[i] != null && !contexts[i].isDisabled()) {
	            	contextThreads[i]=new Thread(contexts[i]);
	            	contextThreads[i].setName(contexts[i].getName() + AdapterConstants.HyadesGA + contexts[i].getUniqueID());
	            	contextThreads[i].setDaemon(true);
	            	contextThreads[i].start();
	            }
	        }
    	}
        running = true;
    }
    
    /**
     * Stop the controller which means stopping all of the contexts if they
     * are still running.
     */
    public void stop() {

	    if (contexts != null && contextThreads != null) {
	       	synchronized(contexts) {
	       	    int contextStopCount = 0;
	       	    /* stop them in reverse order so that the logging context gets stopped last */        	
	            for (int i=contexts.length-1; i>0; i--) {
	 				/* bugzilla 74713 - set stopping flag instead of calling Context.stop() because
					 * we're running in a different thread than the context.  Also, only stop the
					 * context if the context thread is still alive
					 */
	                if (contexts[i] != null && contextThreads.length > i && contextThreads[i] != null  && contextThreads[i].isAlive()) {
	                    contexts[i].setStopping(true);
	                    contextStopCount++;
	                }
	            }
		        /* If other contexts are stopping Then sleep before stopping 
		         * the logging context to allow the other contexts
	    	     * to log messages and end.
	             * bugzilla 91218 - only sleep if there are contexts in the
	             * process of stopping.
	    		 */
	            if (contextStopCount > 0) {
	            	try {
	            		Thread.sleep(1500);
	            	}
	            	catch (InterruptedException e) {
	            	
	            	}
	            }
	            // Stop the logging context.
	            if (contexts[0] != null && contextThreads.length > 0 && contextThreads[0] != null  && contextThreads[0].isAlive()) {
	                contexts[0].setStopping(true);
	                // Wait until logging context is finished
	                while (contextThreads[0] != null  && contextThreads[0].isAlive()) {
	                	try {
		            		Thread.sleep(200);
		            		// System.out.println("Waited a fifth of a second for logging context to end");
		            	}
		            	catch (InterruptedException e) {
		            	
		            	}
	                }
	            }
	    	}
    	}
        running = false;
    }
    
	/**
	 * This stop method will still cause the contexts to be stopped but will
	 * not call the context listener methods when flushing the components.
	 */    
	public void hardStop() {
		synchronized(contexts) {
			if (contexts != null && contextThreads != null)
				/* stop them in reverse order so that the logging context gets stopped last */
				for (int i=contexts.length-1; i>=0; i--) {
					/* bugzilla 74713 - set hard stop flag instead of calling Context.stop() because
					 * we're running in a different thread than the context.  Also, only stop the
					 * context if the context thread is still alive
					 */
					if (contexts[i] != null && contextThreads.length > i && contextThreads[i] != null && contextThreads[i].isAlive()) {
						// Set hardStop flag to stop the context
						contexts[i].setHardStop();
					}
				}
		}
		running = false;
	}
    
	/**
	 * Get the set of Context objects
	 * @return the set of Context objects
	 */
    public IContext[] getContexts() {
    	synchronized(contexts) {
	    	// Ensure the contexts have been created
	    	if (contexts == null || contexts.length <= 1) {
	    		return null;
	    	}
			// Exclude the internal logging context
			IContext newContextSet[] = new IContext[contexts.length-1];
			for (int i=1; i < contexts.length; i++) {
				newContextSet[i-1] = contexts[i];
			}
			return newContextSet;
    	}
    }
    
    /**
     * Set the name of the file containing the configurations for the
     * contexts.
     * @param config - name of the context configuation file
     */
    public void setContextConfigPath(String config) {
        contextConfigurationFile = config;
    }
    
	/**
	 * Get the name of the file containing the configurations for the contexts
	 * @return the contextConfigurationFile
	 */
	public String getContextConfigPath() {
		return contextConfigurationFile;
	}

	/**
     * Set the name of the file containing the configurations for the
     * components of the contexts.
     * @param config - name of the component configuation file
     */
    public void setComponentConfigPath(String config) {
        componentConfigurationFile = config;
    }

    /**
     * Get the name of the file containing the configurations for the components of the contexts.
	 * @return the componentConfigurationFile
	 */
	public String getComponentConfigPath() {
		return componentConfigurationFile;
	}

    /*
     * Validates an adapter file against the schema files.
     */
    private void validateAdapterConfigurations(InputStream inAppStream, IProcessUnit logger) throws AdapterInvalidConfig {
    	AdapterConfigValidator validator = new AdapterConfigValidator(logger);
    	try{
    		validator.validate(inAppStream);
    	}catch(AdapterException e){    		
    		log(e.toString());
    	}    	
    }
    
    /**
     * Prepare the adapter for execution.  This involves reading and validating the adapter 
     * configuration file(s), getting the context listeners from eclipse, starting the internal
     * logging context, and initializing the contexts.
     * @param validating  boolean flag to indicate this method is called as part of adapter validation
     */
    public void prepareAdapter(boolean validating) throws AdapterException {
    	/* Open the context and configuration files */
        try {
    		inContextParams = new FileInputStream(contextConfigurationFile);
    		if (singleFileInputMode) {
    			inAppParams = new FileInputStream(contextConfigurationFile);
    		}
    		else {
    			inAppParams = new FileInputStream(componentConfigurationFile);
    		}
    	}
    	catch(FileNotFoundException e) {
    		String filename=null;
    		if(inContextParams==null) {
    			filename=contextConfigurationFile;
    		}
    		else {
    			filename=componentConfigurationFile;
    			try {
    				inContextParams.close();
    			}
    			catch(IOException eprime) {
    				/* We will ignore if this fails.  It should be successful as we just opened the file */
    			}	
    		}
        	/* We cannot open the adapter file */
        	throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Open_ERROR_", filename));
    	}
    	catch (Throwable e) {
     		String filename=null;
    		if(inContextParams==null) {
    			filename=contextConfigurationFile;
    		}
    		else {
    			filename=componentConfigurationFile;
    			try {
    				inContextParams.close();
    			}
    			catch(IOException eprime) {
    				/* We will ignore if this fails.  It should be successful as we just opened the file */
    			}	
    		}
        	/* We cannot open the adapter file */
        	throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Open_ERROR_", filename),e);
    	}
        
        // build the contexts based on configurations     	
        try {
        	contexts = createContextsAndComponents(inContextParams);
        	synchronized(contexts) {
        		setComponentConfigurations(inAppParams);
        	}
	        
	        /* We are done with the files.  Lets close them */
	        try {
	        	inContextParams.close();
	        	if(!singleFileInputMode) {
	        		inAppParams.close();
	        	}	
	        }
	        catch(IOException e) {
	        	/* We just had the file open. We are now closing it */
	        }

            /* Before we start the contexts locate any IContextListeners that
             * are registered with the plugin.  This only works when we are running
             * as a plugin inside of Eclipse.  Outside of Eclipse there is no notion
             * of IContextListeners.
             */
	        if (AdapterUtilities.isWorkbench()) {
	            try {
	                List contextListeners = AdapterPlugin.getContextListeners();
	
	                /* If this context has a listener then set it */
	                if (contextListeners != null) {
	                    Iterator listenerIterator = contextListeners.iterator();
	                    while (listenerIterator.hasNext()) {
	                        IContextListener listener = (IContextListener) listenerIterator.next();
	                        String[] targetContexts = listener.getTargetContextUniqueIds();
	                        for (int j = 0; j < targetContexts.length; j++) {
	                            for (int k = 0; k < contexts.length; k++) {
	                                if (contexts[k].getUniqueID().equals(targetContexts[j])) {
	                                    contexts[k].setContextListener(listener);
	                                }
	                            }
	                        }
	                    }
	                }
	            }
	            catch (AdapterException e) {
	            	throw e;
	            }
	            catch (Throwable e) {
	                throw new AdapterException(Messages.getString("HyadesGAInitialization_GetContextListeners_Failure_ERROR_"), e);
	            }
	        }
            
            /* Start the logging context in its entirty before we continue with anything else */
            IProcessUnit logger=startInternalLoggingContext();

            /* Validate the adapter configuration file against the schema files before starting the rest of the contexts.  
             * It would have been good to have done this above, however, we want our internal logging context running so that we 
             * can report any errors during validation
             */            
            inAppParams = new FileInputStream(contextConfigurationFile);
            validateAdapterConfigurations(inAppParams, logger);
 
            if (!singleFileInputMode) {
                inAppParams = new FileInputStream(componentConfigurationFile);
                validateAdapterConfigurations(inAppParams, logger);
            }
            
            // Count the number of contexts that are initialized and ready to execute
            int contextsReadyCount = 0;
            AdapterException initException = null;
            
            synchronized(contexts) {
	            for (int i = 1; i < contexts.length; ++i) {
	                if (contexts[i] != null) {
	                	
	                	/* Set the logger for this context to be the internal logging sensor */
	                	contexts[i].setLogger(logger);
	                	
	                	/* Set the validating status for the context */
	                	contexts[i].setValidating(validating);
	                	
	                	/* bugzilla 96433
	                	 * Set logging level of context and components if it needs to be globally set
	                	 * and it is not being validated.
	                	 */ 
	                	if (!validating && loggingLevel > -1) {
	                		contexts[i].setLoggingLevel(loggingLevel);
	                		IComponent comp[] = contexts[i].getComponents();
	                		for (int j=0; j<comp.length; j++) {
	                			comp[j].setLoggingLevel(loggingLevel);
	                		}
	                	}
	                	
	                    // set all the context config info
	                    if (!(contexts[i].init())) {
	                    	contexts[i]=null;
	                    	/* Make sure we log that this context will not be started */
	                    	log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	continue;
	                    }
	                    // set all the component config info
	                    
	                    /* Setup the configuration information for this context.  At this point in time the context
	                     * may fail to initialize itself properly.  If that is the case then this context should be 
	                     * disabled.
	                     */
	                    try {
	                    	contexts[i].update();
	                    	// Only increment context ready count if context is not disabled
	                    	if (!contexts[i].isDisabled()) {
	                    		contextsReadyCount++;
	                    	}
	                    }
	                    catch(AdapterException e) {
	                    	if (!validating) {
	                    		contexts[i]=null;
	                    		/* Make sure we log that this context will not be started */
	                    		log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	}
	                    	initException = e;
	                    }
	                }
	            }
            }
            // If there are no contexts ready to execute then quit! 
            if (contextsReadyCount == 0) {
            	if (initException != null) {
            		throw initException;
            	}
            	else {
            		throw new AdapterException(Messages.getString("HyadesGAContextFatal_ERROR_"));
            	}
            }
        }   
        catch(Throwable e) {
        	/* RKD:  Our caller will need to use our exception information for now to handle the error.*/
			/* Don't log anything here.  Assume the caller handles the exception and 
			 * logs a message if necessary.
             * log(Messages.getString("HyadesGAAdapterFatal_ERROR_"));
          	 * log(e.toString());
			 */
        	if (e instanceof AdapterException) {
        		throw (AdapterException)e;
        	}
        	
        	// Wrap non-AdapterException in an AdapterException
        	String errorMsg = e.getMessage();
        	if (errorMsg == null) {
        	 	errorMsg = e.toString();
        	}
            throw new AdapterException(errorMsg);
        }
        finally {
        	
        	/* Close our configuration file */
            try {
                if (inAppParams != null) {
                	inAppParams.close();
                }
                if (inContextParams != null) {
                	inContextParams.close();
                }
            }
            catch (IOException e) {
            	/* We couldn't close the configuration files.  This should only occur if we failed to 
            	 * open the file in the first place.
            	 */
                log(e.toString());
            }
        }
    }
 
    /**
     * Prepare the adapter configuration for execution.  This involves 
     * starting the internal logging context, and initializing the contexts.
     * @param validating  boolean flag to indicate this method is called as part of adapter validation
     */
    public void prepareConfiguration(boolean validating) throws AdapterException {
  	
        try {            
            /* Start the logging context in its entirty before we continue with anything else */
            IProcessUnit logger=startInternalLoggingContext();

            // Count the number of contexts that are initialized and ready to execute
            int contextsReadyCount = 0;
            AdapterException initException = null;
            
            synchronized(contexts) {
	            for (int i = 1; i < contexts.length; ++i) {
	                if (contexts[i] != null) {
	                	
	                	/* Set the logger for this context to be the internal logging sensor */
	                	contexts[i].setLogger(logger);
	                	
	                	/* Set the validating status for the context */
	                	contexts[i].setValidating(validating);
	                	
	                	/* bugzilla 96433
	                	 * Set logging level of context and components if it needs to be globally set
	                	 * and it is not being validated.
	                	 */ 
	                	if (!validating && loggingLevel > -1) {
	                		contexts[i].setLoggingLevel(loggingLevel);
	                		IComponent comp[] = contexts[i].getComponents();
	                		for (int j=0; j<comp.length; j++) {
	                			comp[j].setLoggingLevel(loggingLevel);
	                		}
	                	}
	                	
	                    // set all the context config info
	                    if (!(contexts[i].init())) {
	                    	contexts[i]=null;
	                    	/* Make sure we log that this context will not be started */
	                    	log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	continue;
	                    }
	                    // set all the component config info
	                    
	                    /* Setup the configuration information for this context.  At this point in time the context
	                     * may fail to initialize itself properly.  If that is the case then this context should be 
	                     * disabled.
	                     */
	                    try {
	                    	contexts[i].update();
	                    	// Only increment context ready count if context is not disabled
	                    	if (!contexts[i].isDisabled()) {
	                    		contextsReadyCount++;
	                    	}
	                    }
	                    catch(AdapterException e) {
	                    	if (!validating) {
	                    		contexts[i]=null;
	                    		/* Make sure we log that this context will not be started */
	                    		log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	}
	                    	initException = e;
	                    }
	                }
	            }
            }
            // If there are no contexts ready to execute then quit! 
            if (contextsReadyCount == 0) {
            	if (initException != null) {
            		throw initException;
            	}
            	else {
            		throw new AdapterException(Messages.getString("HyadesGAContextFatal_ERROR_"));
            	}
            }
        }   
        catch(Throwable e) {
        	/* RKD:  Our caller will need to use our exception information for now to handle the error.*/
			/* Don't log anything here.  Assume the caller handles the exception and 
			 * logs a message if necessary.
             * log(Messages.getString("HyadesGAAdapterFatal_ERROR_"));
          	 * log(e.toString());
			 */
        	if (e instanceof AdapterException) {
        		throw (AdapterException)e;
        	}
        	
        	// Wrap non-AdapterException in an AdapterException
        	String errorMsg = e.getMessage();
        	if (errorMsg == null) {
        	 	errorMsg = e.toString();
        	}
            throw new AdapterException(errorMsg);
        }

    }
    
    /**
     * parses Context configurations and build the Context objects
     * as well as set teh context config for each component
     */
    private Context[] createContextsAndComponents(InputStream inContextStream) throws PreparationException {

        Document doc = null;
        Context[] contexts = null;
        try {
            doc = docFactory.newDocumentBuilder().parse(inContextStream);

            //Add the adapter logging context as default:
            Element loggingContext = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXT);
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Context instance for the current component");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.impl.AdapterContext");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "60");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, AdapterXMLConstants.HyadesGAAdapterContextName);
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "context");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NB1F4ED002DA11D8A519FBE7C98C2F53");

            Element loggingSensor = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter logging sensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.AdapterSensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            // bugzilla 84698 - If there is an outputter Then let WARNING or higher messages be logged.
            if (logOutputter != null) {
            	loggingSensor.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
            }
            // Otherwise let all messages be logged
            else {
            	loggingSensor.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "0");
            }
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogSensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "sensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NF991E0004FF11D8930381B6A308BEB5");

            loggingContext.appendChild(loggingSensor);

            Element loggingOutputter = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter logging outputter");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionAttributeName, "");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionDescriptionAttributeName, "");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "outputter");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");

            // Add the outputter specified by the user (eg. set by StaticParserWrapper in the log import case)
            if (logOutputter != null) {
            	//Set the logging level so we get Warning, Critical and Fatal error messages
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, logOutputter.getClass().getName());
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogOutputter");
                
                /*************************************************************************************************                
                 * bugzilla 79014 
                 * Comment this out because we should not need to log to a file in the log import
                 * case.  GLA messages will be handled by the outputter set by the user.
                 * However, we'll keep the code here in case we find it necessar to log to a file as well.              
                 *                  
                 * loggingContext.appendChild(loggingOutputter);
                 *               
                 * // Create a file outputter too
                 * loggingOutputter = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter File logging outputter");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionAttributeName, "");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionDescriptionAttributeName, "");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "outputter");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "AdapterFileLoggerId");
                 * //Set the logging level so we get Warning, Critical and Fatal error messages
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.AdapterLogFileOutputter");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogFileOutputter");
                 *
                 **************************************************************************************************/
            }
	        //Add the Eclipse Problems View outputter if in Eclipse mode. This is used when the context runs in the GLA editor.
	        else if (AdapterUtilities.isWorkbench()) {
            	//Set the logging level so we get any messages that are at least informational
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "10");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.GlaTaskOutputter");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "CBEEclipseProblemsViewOutputter");
            }
            //Add the log file outputter if in standalone mode:
            else {
            	//Set the logging level so we get Warning, Critical and Fatal error messages
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.AdapterLogFileOutputter");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogFileOutputter");                
            }      

            loggingContext.appendChild(loggingOutputter);

            NodeList contextsNodeList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTS);

            if (contextsNodeList.getLength() == 0) {

                //Create a contexts element:	
                Element contextsElement = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTS);
                
                /* Insert the logging context at the first of the child list of elements */
                NodeList children=contextsElement.getChildNodes();
                for(int i=0; i<children.getLength(); i++) {
                	if(children.item(i).getNodeType()==Node.ELEMENT_NODE) {
                		contextsElement.insertBefore(loggingContext, children.item(i));
                		break;
                	}	
                }

                doc.getDocumentElement().appendChild(contextsElement);
            }
            else {

                //ASSUMPTION:  Only one contexts element permitted.	

                //Retrieve the contexts element:	
                Node contextsElement = contextsNodeList.item(0);
                /* Insert the logging context at the first of the child list of elements */
                NodeList children=contextsElement.getChildNodes();
                for(int i=0; i<children.getLength(); i++) {
                	if(children.item(i).getNodeType()==Node.ELEMENT_NODE) {
                		contextsElement.insertBefore(loggingContext, children.item(i));
                		break;
                	}	
                }

                doc.getDocumentElement().appendChild(contextsElement);
            }

            try {
                NodeList contextList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXT);
                // check to see if this file contains everything or just the context config
                NodeList tempInstanceList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);
                if (tempInstanceList.getLength() > 0)
                    singleFileInputMode = true;
                else
                    singleFileInputMode = false;
                int count = contextList.getLength();
                contexts = new Context[count];
                int j = 0;
                Element element = null;
                Context context = null;
                Component component = null;
                
                for (int i = 0; i < count; ++i) {
                    //TODO: HS need to support imbedded/nested contexts/components
                    // Extract each root context and copy the expected attributes
                    element = (Element) contextList.item(i);
                	/* try and build the context.  A number of things can go wrong here as we use relection to build the instance. */
                	context = ContextFactory.buildContext(element.getAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGANameAttributeName));	
                	context.setContextConfiguration(element);

                    //
                    // get a list of all sub elements and assume they are components
                    NodeList componentList = element.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
                    IComponent[] compArray = null;
                    int componentCount = componentList.getLength();
                    compArray = new IComponent[componentCount];
                    for (int k = 0, l = 0; k < componentCount; k++) {
                        // Extract each component config
                        element = (Element) componentList.item(k);

                        // Check if we have a log outputter object already and if so then use that
                        if (i == 0 && k ==1 && logOutputter != null) {
                        	component = (Component)logOutputter;
                        	component.setName(element.getAttribute(AdapterXMLConstants.HyadesGANameAttributeName));
                        	component.setUniqueID(element.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName));
                        	component.setExecutableClassName(element.getAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName));
                        }
                        else {
                        	component = ComponentFactory.buildComponent(element.getAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGANameAttributeName));
                        }
                        component.setContextConfiguration(element);
                        compArray[l++] = component;
                    }
                    // put the components in the context
                    context.setComponents(compArray);
                    // put this context in the controller's array
                    contexts[j++] = context;
                }
            }
            catch (PreparationException e) {
                throw e;
            }
            catch (Exception e) {
                throw new PreparationException(Messages.getString("HyadesGAInitialization_ContextConfiguration_Failure_ERROR_", contextConfigurationFile), e);
            }
        }
        catch (SAXException e) {
        	/* We have a problem parsing the configuration file ABORT */
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", contextConfigurationFile), e);
        }
        catch (ParserConfigurationException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", contextConfigurationFile), e);
        }
        catch (IOException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", contextConfigurationFile), e);
        }
        return contexts;
    }

    /**
     * CreateContextsConfig takes in an entire component configurations file and
     * separates out the context instances and gives each context the sub tree for itself and
     * it's components.
     */
    private void setComponentConfigurations(InputStream inAppStream) throws AdapterInvalidConfig, PreparationException {

        Document doc = null;

        try {

            doc = docFactory.newDocumentBuilder().parse(inAppStream);

            //Add the adapter internal logging context instance as default:
            Element loggingSensorInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_SENSOR);
            loggingSensorInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "An adapter CBE sensor");
            loggingSensorInstance.setAttribute(AdapterXMLConstants.HyadesGAmaximumBlockingAttributeName, "5");
            loggingSensorInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NF991E0004FF11D8930381B6A308BEB5");

            Element loggerContextInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);
            loggerContextInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Context instance for the current component");
            /* Configure the internal logging context to run forever or until the adatper is explicitly stopped */ 
            loggerContextInstance.setAttribute(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_CONTINUOUS_OPERATION, "true");
            loggerContextInstance.setAttribute(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_MAXIMUM_IDLE_TIME, "0");
            loggerContextInstance.setAttribute(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_PAUSE_INTERVAL, "10");
            loggerContextInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NB1F4ED002DA11D8A519FBE7C98C2F53");

            loggerContextInstance.appendChild(loggingSensorInstance);

            // Configure the log outputter for the log import case
            if (logOutputter != null) {
				Element loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter log outputter");
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");
				
				/* This outputter is created and configured by the user so there will not be any configuration properties for it. */
				
                loggerContextInstance.appendChild(loggingOutputterInstance);
                
                /*************************************************************************************************                
                 *              bugzilla 79014 
                 *              Comment this out because we should not need to log to a file in the log import
                 *              case.  GLA messages will be handled by the outputter set by the user.
                 *              However, we'll keep the code here in case we find it necessary to log to a file as well.              
                 *   
                 *              // Get the directory for the GLA log file
                 *              String glaLogDirectory = ".";
                 *       		try {
                 *       			
                 *       			// Try to get the plugin's workspace directory (e.g. <workspace>/.metadata/plugins/org.eclipse.hyades.logging.adapter) 
                 *
                 *       			Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
                 *       			
                 *       			Method getPluginStateLocationMethod = platformClass.getMethod("getPluginStateLocation",new Class[]{Class.forName("org.eclipse.core.runtime.Plugin")});
                 *       			
                 *       			Object iPathObject =  getPluginStateLocationMethod.invoke(null,new Object[]{AdapterPlugin.getPlugin()});
                 *       			
                 *       			Class iPathClass = iPathObject.getClass();
                 *       			
                 *       			Method toOSStringMethod = iPathClass.getMethod("toOSString",null);
                 *       			
                 *       			glaLogDirectory = (String)(toOSStringMethod.invoke(iPathObject,null));
                 *       		}
                 *       		catch (Exception e) {
                 *       			// Ignore this and use the current directory for the GLA log file
                 *       		}
                 *       		
                 *               // Add the file logger component configuration
                 *               loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
                 *               loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Single file outputter");
                 *               loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "AdapterFileLoggerId");
                 *
                 *				 Element outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
                 *               outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, glaLogDirectory);
                 *				 outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAdirectoryAttributeName);
                 *               loggingOutputterInstance.appendChild(outputterProperty);
                 *               
                 *				 outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
                 *				 outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, "hgla.log");
                 *				 outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAfileNameAttributeName);
                 *				 loggingOutputterInstance.appendChild(outputterProperty);                
                 *				
                 *               loggerContextInstance.appendChild(loggingOutputterInstance);
                 * 
                 ************************************************************************************/	
            }
            // Configure the Problems View outputter for the GLA editor case
            else if (AdapterUtilities.isWorkbench()) {
            	
				Element loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Eclipse error dialog outputter");
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");
				
				/* RKD:  We need to inform the outputter of the configuration path so it can create markers for the resource */
		        Element resourcePathProperty=doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
	            resourcePathProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName, "resourceName");
	            resourcePathProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, contextConfigurationFile);
	                
	            loggingOutputterInstance.appendChild(resourcePathProperty);
                loggerContextInstance.appendChild(loggingOutputterInstance);			
            }
            else{

                Element loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
                loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Single file outputter");
                loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");

				Element outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, ".");
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAdirectoryAttributeName);
                loggingOutputterInstance.appendChild(outputterProperty);
                
				outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, "hgla.log");
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAfileNameAttributeName);
				loggingOutputterInstance.appendChild(outputterProperty);                
				
                loggerContextInstance.appendChild(loggingOutputterInstance);
            }

            NodeList configurationNodeList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONFIGURATION);

            if (configurationNodeList.getLength() == 0) {

                //Create a configuration element:	
                Element loggerConfigurationInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONFIGURATION);
                loggerConfigurationInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "The component level configurations for this adapter");
                loggerConfigurationInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N06FBD3004FF11D8BCF4CFA9EA8F31E7");

                loggerConfigurationInstance.appendChild(loggerContextInstance);

                doc.getDocumentElement().appendChild(loggerConfigurationInstance);
            }
            else {

                //ASSUMPTION:  Only one configuration element permitted.	

                //Retrieve the configuration element:	
                Node loggerConfigurationInstance = configurationNodeList.item(0);
                loggerConfigurationInstance.appendChild(loggerContextInstance);

                doc.getDocumentElement().appendChild(loggerConfigurationInstance);
            }

            try {
                // get a list of all the context instances and associates each with a context
                NodeList contextInstanceList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);

                int contextInstanceCount = contextInstanceList.getLength();
                for (int i = 0; i < contextInstanceCount; ++i) {
                    try {
                        //find the matching Context and Context Instance
                        Element contextElement = (Element) contextInstanceList.item(i);
                        String contextInstanceID = contextElement.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName);

                        int contextCount = contexts.length;
						/* Throw an exception if we have a mismatch in the number of Context's and
						 * the number of ContextInstance's.
						 */
						if (contextInstanceCount != contextCount) {
							throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextConfigurationErrorContextCountMismatchFatal_ERROR_"));
						}                       
                        
                        boolean contextFound = false;
                        for (int j = 0; j < contextCount; j++) {
                            if (contexts[j].getUniqueID().equals(contextInstanceID)) {
                                contexts[j].setConfiguration(contextElement);
                                contextFound = true;
                                // so now we have a good context which may or may not have components
                                //assume each child of the contextInstance is a component
                                NodeList componentInstanceList = contextElement.getChildNodes();
                                int numberOfComponentInstances = componentInstanceList.getLength();
                                // get the components from the context
								IComponent components[] = contexts[j].getComponents();
								int componentCount = components.length;

								int componentInstanceCount = 0;
                                for (int k = 0; k < numberOfComponentInstances; k++) {
                                    if (componentInstanceList.item(k).getNodeType() == Node.ELEMENT_NODE) {
                                        Element componentElement = (Element) componentInstanceList.item(k);
                                        String componentInstanceID = componentElement.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName);
                                        boolean componentFound = false;
                                        componentInstanceCount++;
                                        // walk through the components of the context and set the config
                                        for (int l = 0; l < componentCount; l++) {
                                            if (components[l].getUniqueID().equals(componentInstanceID)) {
                                                components[l].setConfiguration(componentElement);
                                                componentFound = true;
                                                /* bugzilla 82193
                                                 * If this is a formatter and we are running in the GLA editor
                                                 */
                                                if (componentElement.getNodeName().equals(AdapterXMLConstants.ELEMENT_TAG_NAME_FORMATTER) && 
                                                		logOutputter == null &&	AdapterUtilities.isWorkbench()) {
                                                	/* Add the test attribute to the formatter element to indicate we are running
                                                	 * in the GLA editor environment.  
                                                	 */
                                                	componentElement.setAttribute(AdapterConstants.AttrubuteName_Test,AdapterConstants.AttrubuteValue_Test_True);
                                                }
                                                break;
                                            }
                                        }
                                        if (!componentFound) {
											throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextInstanceConfigurationErrorComponentIdNotFoundFatal_ERROR_",componentInstanceID , contexts[j].getUniqueID()));
                                        }
                                    }
                                }
								/* Throw an exception if we have a mismatch in number of components between
								 * the context and the contextInstance.
								 */
								if (componentInstanceCount != componentCount) {
									throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextInstanceConfigurationErrorComponentMismatchFatal_ERROR_",contexts[j].getUniqueID()));
								}
                                break;
                            }
                        }
						if (!contextFound) {
							throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextInstanceConfigurationErrorContextIdNotFoundFatal_ERROR_", contextInstanceID));
						}
                    }
                    catch (AdapterInvalidConfig e) {
                    	throw e;
                    }
                    catch (Exception e) {
                        throw new PreparationException(Messages.getString("HyadesGAInitialization_ContextInstanceConfiguration_Failure_ERROR_", componentConfigurationFile), e);
                    }
                }
            }
            catch (AdapterInvalidConfig e) {
            	throw e;
            }
            catch (Exception e) {
                throw new PreparationException(Messages.getString("HyadesGAInitialization_ContextInstanceConfiguration_Failure_ERROR_", componentConfigurationFile), e);
            }
        }
        catch (SAXException e) {
        	/* We have a problem parsing the configuration file ABORT */
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", componentConfigurationFile), e);
        }
        catch (ParserConfigurationException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", componentConfigurationFile), e);
        }
        catch (IOException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", componentConfigurationFile), e);
        }
    }
    /**
     * run provides the basic loop for a Controller thread.  It starts the Controller thread and
     * then monitors it.
     */
    public void run() {
        start();
        while (isRunning()) {
            synchronized (this) {
                try {
                    wait(sleepTime);
                }
                catch (Exception e) {
                    log(e.toString());
                }
                if (areContextsDone()) {
               	    // Stop the Adapter logging context
                    stop();
                }
            }
        }
    }
    /**
     * return false if any context is still alive, otherwise return true 
     */
    private boolean areContextsDone() {
        if (contextThreads != null) {
        	/* Ignore the internal logging context.  hense we start at index 1 */
            for (int i = 1; i < contextThreads.length; i++) {
                if (contextThreads[i] != null) {
                    if (contextThreads[i].isAlive() && !(contexts[i] instanceof AdapterContext))
                        return false;
                }
            }
        }
        return true;
    }
    
    /**
     * clean a controller by nulling out everything
     */
    private void clean() {
        if (contexts != null) {
            for (int i = 0; i < contexts.length; i++) {
                contexts[i] = null;
            }
        }
        contexts = null;
        //		hashContextConfig.clear();
    }
    
    /**
     * Starts the internal logging context.
     *
     */
    private IProcessUnit startInternalLoggingContext() {
    	contexts[0].init();
    	contextThreads=new Thread[contexts.length];
        try {
        	contexts[0].update();
        	// bugzilla 96433 - Reset the logging context status
        	contexts[0].setStopping(false);
        	contextThreads[0]=new Thread(contexts[0]);
        	contextThreads[0].setName(contexts[0].getName() + AdapterConstants.HyadesGA + contexts[0].getUniqueID());
        	contextThreads[0].setDaemon(true);
        	contextThreads[0].start();
        	return (IProcessUnit)contexts[0].getComponents()[0];
        	
        }
        catch(AdapterException e) {
        	/* Since we are generating the context content we should not have configuration problems */
        	/* However, we may get an exception here if the GLA logging cannot be initialized. */
			log(Messages.getString("HyadesGAInitialization_Internal_Logging_Not_Started_WARN_", e.getLocalizedMessage()));
        }
        catch(Exception e) {
        	/* Catch any other kind of exception and log a message */
        	log(Messages.getString("HyadesGAInitialization_Internal_Logging_Not_Started_WARN_", e.toString()));
        }
        return null;
    }
    
    /**
     * Log the string message to standard error since the logging outputter(s)
     * associated with the <code>AdapterSensor</code> logger will never be
     * started.
     * 
     * @param logRecord The string message to be logged to standard error.
     */
    public void log(String logRecord) {
    	if(!AdapterUtilities.isWorkbench()) {
    		System.err.println(logRecord);
    	}
       
    }
    
    /**
     * Get the status of the contexts
     * @return the array of Status objects representing the status of the contexts
     */
    public Status [] getStatus() {
    	Status [] statuses = null; 
    	
    	/* If there are context then get their status */
	    if (contexts != null) {
	    	synchronized(contexts) {
	        	statuses = new Status[contexts.length];
	        	/* get the status for each context */        	
	            for (int i=0; i < contexts.length; i++) {
	            	if (contexts[i] != null) {
	            		statuses[i] = contexts[i].getContextStatus();
	            	}
	            	else {
	            		statuses[i] = null;
	            	}
	            }
	        }
    	}
    	
    	return statuses;
    }
	
	/**
	 * Get the custom Outputter that the internal logging context is using.
	 * @return Returns the custom Outputter that the internal logging context is using.
	 */
	public IOutputter getLogOutputter() {
		return logOutputter;
	}
	/**
	 * Sets the custom Outputter for the internal logging context to use.
	 * @param logOutputter The custom Outputter for the internal logging context.
	 */
	public void setLogOutputter(IOutputter logOutputter) {
		this.logOutputter = logOutputter;
	}
	
    /**
     * Sets the loggingLevel of the Adapter object.  This value will override 
     * all values in the adapter configuration. The logging level value specified will
     * take effect the next time the Adapter is started. If this method is 
     * not called or is called with a value of -1, the logging levels specified in the
     * adapter configuration will be used.
     * @param newLevel The level of logging that the Adapter will use during execution
     */
	public void setLoggingLevel(short newLevel)
	{
		loggingLevel = newLevel;
	}

	/**
	 * Get the logging level of the Adapter object.
	 * @return the level of logging the Adapter is currently using
	 */
	public short getLoggingLevel() {
		return loggingLevel;
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/hyades/logging/adapter/outputters/CBEFileOutputter.java (-26 / +43 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005,2006 IBM Corporation and others.	2	* Copyright (c) 2005,2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 47-52 Link Here
47	private String fileName = null;	47	private String fileName = null;
48	protected String rawLogFileName = null;	48	protected String rawLogFileName = null;
49	protected FileWriter fw = null;	49	protected FileWriter fw = null;
		50	protected String tmpFileName = null;
		51	protected String tmpDirectory = null;
50		52
51	/**	53	/**
52	* This implementation processes messages represented by an array of CommonBaseEvent objects	54	* This implementation processes messages represented by an array of CommonBaseEvent objects
Lines 188-211 Link Here
188	this.fileName = fileName;	190	this.fileName = fileName;
189	updateConfigurationPropertyChild(AdapterXMLConstants.HyadesGAfileNameAttributeName, fileName);	191	updateConfigurationPropertyChild(AdapterXMLConstants.HyadesGAfileNameAttributeName, fileName);
190	}	192	}
191		193
192	/**	194	/**
193	* update the configuration based on the configuration Element	195	* Read the outputter configuration from the configuration element
194	*/	196	*/
195	public void update() throws AdapterInvalidConfig	197	protected void readConfiguration() {
196	{
197	// first get the basic configuration set
198	super.update();
199
200	/* The directory and fileName may be set already if the
201	* outputter is passed to the adapter as the GLA Adapter Log
202	* Outputter so intialize the local variables with those values.
203	* Note, they will be overwritten below by the values in the
204	* configuration if they are present.
205	*/
206	String directory = getDirectory();
207	String fileName = getFileName();
208
209	// Get configuration	198	// Get configuration
210		199
211	Element element = getConfiguration();	200	Element element = getConfiguration();
Lines 216-224 Link Here
216	// Get the outputter parameters from the outputter properties	205	// Get the outputter parameters from the outputter properties
217	Hashtable outputterProperties = getProperties();	206	Hashtable outputterProperties = getProperties();
218	if (outputterProperties != null && !outputterProperties.isEmpty()) {	207	if (outputterProperties != null && !outputterProperties.isEmpty()) {
219	directory = (String)outputterProperties.get(AdapterXMLConstants.HyadesGAdirectoryAttributeName);	208	tmpDirectory = (String)outputterProperties.get(AdapterXMLConstants.HyadesGAdirectoryAttributeName);
220		209
221	fileName = (String)outputterProperties.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);	210	tmpFileName = (String)outputterProperties.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);
222	}	211	}
223	else if (element != null) {	212	else if (element != null) {
224	/**	213	/**
Lines 234-260 Link Here
234	outputterTypeInstance = outputterNode;	223	outputterTypeInstance = outputterNode;
235	// Get attributes	224	// Get attributes
236	if (outputterTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName))	225	if (outputterTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName))
237	directory = outputterTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName);	226	tmpDirectory = outputterTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName);
238	if (outputterTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName))	227	if (outputterTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName))
239	fileName = outputterTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName);	228	tmpFileName = outputterTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName);
240	}	229	}
241	}	230	}
242	}	231	}
243	}	232	}
244		233	}
		234
		235	/**
		236	* Process the values read from the configuration and perform other initialization
		237	* @throws AdapterInvalidConfig
		238	*/
		239	protected void processConfiguration() throws AdapterInvalidConfig {
245	// We must have a directory and fileName	240	// We must have a directory and fileName
246	if (directory == null \|\| directory.length() == 0 \|\| fileName == null \|\| fileName.length() == 0) {	241	if (tmpDirectory == null \|\| tmpDirectory.length() == 0 \|\| tmpFileName == null \|\| tmpFileName.length() == 0) {
247	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileOutputter_Invalid_Config_File_ERROR_"));	242	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileOutputter_Invalid_Config_File_ERROR_"));
248	}	243	}
249		244
250	// Check if the directory is actually a directory	245	// Check if the directory is actually a directory
251	File dir = new File(directory);	246	File dir = new File(tmpDirectory);
252	if (!dir.isDirectory()) {	247	if (!dir.isDirectory()) {
253	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileOutputter_Invalid_Config_File_ERROR_"));	248	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileOutputter_Invalid_Config_File_ERROR_"));
254	}	249	}
255		250
256	setDirectory(directory);	251	setDirectory(tmpDirectory);
257	setFileName(fileName);	252	setFileName(tmpFileName);
258		253
259	// Get the parent context so we can get the validating flag	254	// Get the parent context so we can get the validating flag
260	boolean validating = false;	255	boolean validating = false;
Lines 274-279 Link Here
274	}	269	}
275		270
276	/**	271	/**
		272	* update the configuration based on the configuration Element
		273	*/
		274	public void update() throws AdapterInvalidConfig
		275	{
		276	// first get the basic configuration set
		277	super.update();
		278
		279	/* The directory and fileName may be set already if the
		280	* outputter is passed to the adapter as the GLA Adapter Log
		281	* Outputter so intialize the local variables with those values.
		282	* Note, they will be overwritten below by the values in the
		283	* configuration if they are present.
		284	*/
		285	tmpDirectory = getDirectory();
		286	tmpFileName = getFileName();
		287
		288	readConfiguration();
		289
		290	processConfiguration();
		291	}
		292
		293	/**
277	* Prepare the file for the log CBE output	294	* Prepare the file for the log CBE output
278	*/	295	*/
279	protected void prepareFile() throws AdapterInvalidConfig	296	protected void prepareFile() throws AdapterInvalidConfig

Lines 1-5 Link Here

(-)src/org/eclipse/hyades/logging/adapter/sensors/SingleOSFileSensor.java (-37 / +55 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005,2006 IBM Corporation and others.	2	* Copyright (c) 2005,2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 97-102 Link Here
97	private File tmpFile = null;	97	private File tmpFile = null;
98	private static String prefix = "hgla";	98	private static String prefix = "hgla";
99		99
		100	protected String tmpFileName = null;
		101	protected String tmpDirectory = null;
		102	protected String tmpConverterCmd = null;
100	/**	103	/**
101	* No-arguement constructor to create a SingleOSFileSensor.	104	* No-arguement constructor to create a SingleOSFileSensor.
102	*/	105	*/
Lines 122-144 Link Here
122	super.stop();	125	super.stop();
123	clean();	126	clean();
124	}	127	}
		128
125	/**	129	/**
126	* Update the configuration based on the configuration Element.	130	* Read the sensor configuration from the configuration element
127	*
128	* @see org.eclipse.hyades.logging.adapter.IComponent#update()
129	*/	131	*/
130	/* (non-Javadoc)	132	protected void readConfiguration() {
131	* @see org.eclipse.hyades.logging.adapter.impl.Sensor#update()
132	*/
133	public void update() throws AdapterInvalidConfig
134	{
135	// first get the basic configuration set
136	super.update();
137	// maximumBlocking is set by the sensor config
138	lastLine = new String[maximumBlocking];
139	String directory = null;
140	String fileName = null;
141	String converterCmdAttribute = null;
142		133
143	Element sensorTypeInstance = null;	134	Element sensorTypeInstance = null;
144	Element sensorNode;	135	Element sensorNode;
Lines 147-157 Link Here
147	// Get the sensor parameters from the sensor properties	138	// Get the sensor parameters from the sensor properties
148	Hashtable sensorProperties = getProperties();	139	Hashtable sensorProperties = getProperties();
149	if (sensorProperties != null && !sensorProperties.isEmpty()) {	140	if (sensorProperties != null && !sensorProperties.isEmpty()) {
150	directory = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAdirectoryAttributeName);	141	tmpDirectory = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAdirectoryAttributeName);
151		142
152	fileName = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);	143	tmpFileName = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);
153		144
154	converterCmdAttribute = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAconverterCmdAttributeName);	145	tmpConverterCmd = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAconverterCmdAttributeName);
155		146
156	converterShell = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAconverterShellAttributeName);	147	converterShell = (String)sensorProperties.get(AdapterXMLConstants.HyadesGAconverterShellAttributeName);
157		148
Lines 169-182 Link Here
169	// Get the sensor parameters from the sensor type instance attributes	160	// Get the sensor parameters from the sensor type instance attributes
170	sensorTypeInstance = sensorNode;	161	sensorTypeInstance = sensorNode;
171	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName)) {	162	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName)) {
172	directory = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName);	163	tmpDirectory = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAdirectoryAttributeName);
173	}	164	}
174	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName)) {	165	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName)) {
175	fileName = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName);	166	tmpFileName = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAfileNameAttributeName);
176	}	167	}
177		168
178	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAconverterCmdAttributeName)) {	169	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAconverterCmdAttributeName)) {
179	converterCmdAttribute = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAconverterCmdAttributeName);	170	tmpConverterCmd = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAconverterCmdAttributeName);
180	}	171	}
181		172
182	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAconverterShellAttributeName)) {	173	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAconverterShellAttributeName)) {
Lines 187-196 Link Here
187	}	178	}
188	}	179	}
189		180
190	if (converterCmdAttribute != null) {	181	if (tmpConverterCmd != null) {
191	converterCmdAttribute = converterCmdAttribute.trim();	182	tmpConverterCmd = tmpConverterCmd.trim();
192	if (converterCmdAttribute.length() == 0) {	183	if (tmpConverterCmd.length() == 0) {
193	converterCmdAttribute = null;	184	tmpConverterCmd = null;
194	}	185	}
195	}	186	}
196		187
Lines 200-208 Link Here
200	converterShell = null;	191	converterShell = null;
201	}	192	}
202	}	193	}
203
204	filterExitClassInstance = getFilterExitClassInstance();
205
206		194
207	// Get the parent context so we can get the charset and	195	// Get the parent context so we can get the charset and
208	// continuous operation flag	196	// continuous operation flag
Lines 217-233 Link Here
217	break;	205	break;
218	}	206	}
219	}	207	}
		208	}
		209
		210	/**
		211	* Process the values read from the configuration and perform other initialization
		212	* @throws AdapterInvalidConfig
		213	*/
		214	protected void processConfiguration() throws AdapterInvalidConfig {
220	// Check if the directory and fileName properties are non null	215	// Check if the directory and fileName properties are non null
221	if (directory == null \|\| directory.trim().length() == 0 \|\|	216	if (tmpDirectory == null \|\| tmpDirectory.trim().length() == 0 \|\|
222	fileName == null \|\| fileName.trim().length() == 0) {	217	tmpFileName == null \|\| tmpFileName.trim().length() == 0) {
223	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileSensor_Invalid_Config_File_ERROR_"));	218	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileSensor_Invalid_Config_File_ERROR_"));
224	}	219	}
		220
		221	filterExitClassInstance = getFilterExitClassInstance();
225		222
		223	// maximumBlocking is set by the sensor config
		224	lastLine = new String[maximumBlocking];
226		225
227	/* Assume the fileName specified is a regular expression and try to	226	/* Assume the fileName specified is a regular expression and try to
228	* use the MultipleFilesReader class.	227	* use the MultipleFilesReader class.
229	*/	228	*/
230	mfr = new MultipleFilesReader(directory, fileName, tmpLog);	229	mfr = new MultipleFilesReader(tmpDirectory, tmpFileName, tmpLog);
231	mfr.init();	230	mfr.init();
232		231
233	// If only one file matches the regex, use the original SingleOSFileSensor	232	// If only one file matches the regex, use the original SingleOSFileSensor
Lines 246-264 Link Here
246	String fn = mfr.getNext();	245	String fn = mfr.getNext();
247	//We must have a vaild directory and fileName that exists on the local file system:	246	//We must have a vaild directory and fileName that exists on the local file system:
248	if (fn == null \|\| fn.trim().length() == 0 \|\|	247	if (fn == null \|\| fn.trim().length() == 0 \|\|
249	(converterCmdAttribute == null && !(new File(fn).canRead()))) {	248	(tmpConverterCmd == null && !(new File(fn).canRead()))) {
250	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileSensor_Invalid_Config_File_ERROR_"));	249	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileSensor_Invalid_Config_File_ERROR_"));
251	}	250	}
252	setFileName(new File(fn).getName()); // Because the name is fully-qualified	251	setFileName(new File(fn).getName()); // Because the name is fully-qualified
253	}	252	}
254	else { // no match at all	253	else { // no match at all
255	// If there was no converter command to generate the log file and the sensor is not running in a continuous context then throw an exception	254	// If there was no converter command to generate the log file and the sensor is not running in a continuous context then throw an exception
256	if (converterCmdAttribute == null && !continuousContext) {	255	if (tmpConverterCmd == null && !continuousContext) {
257	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileSensor_Invalid_Config_File_ERROR_"));	256	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_SingleFileSensor_Invalid_Config_File_ERROR_"));
258	}	257	}
259	else {	258	else {
260	// use the original file name, assuming the converter command will generate the file	259	// use the original file name, assuming the converter command will generate the file
261	setFileName(fileName.trim());	260	setFileName(tmpFileName.trim());
262	}	261	}
263	}	262	}
264	}	263	}
Lines 282-289 Link Here
282	}	281	}
283	}	282	}
284		283
285	setDirectory(directory.trim());	284	setDirectory(tmpDirectory.trim());
286	setConverterCommand(converterCmdAttribute);	285	setConverterCommand(tmpConverterCmd);
287		286
288	CommonBaseEvent event = getEventFactory().createCommonBaseEvent();	287	CommonBaseEvent event = getEventFactory().createCommonBaseEvent();
289	event.setMsg(Messages.getString("HyadesGASensor_SingleOSFileSensor_Configuration_INFO_",getFileName(), getDirectory(), getConverterCommand()));	288	event.setMsg(Messages.getString("HyadesGASensor_SingleOSFileSensor_Configuration_INFO_",getFileName(), getDirectory(), getConverterCommand()));
Lines 301-306 Link Here
301	}	300	}
302	}	301	}
303	}	302	}
		303
		304	/**
		305	* Update the configuration based on the configuration Element.
		306	*
		307	* @see org.eclipse.hyades.logging.adapter.IComponent#update()
		308	*/
		309	/* (non-Javadoc)
		310	* @see org.eclipse.hyades.logging.adapter.impl.Sensor#update()
		311	*/
		312	public void update() throws AdapterInvalidConfig
		313	{
		314	// first get the basic configuration set
		315	super.update();
		316
		317	readConfiguration();
		318
		319	processConfiguration();
		320
		321	}
304		322
305	/**	323	/**
306	* simulates a getNext	324	* simulates a getNext

Lines 1-7 Link Here

(-)src/org/eclipse/hyades/logging/adapter/Adapter.java (-9 / +22 lines)
1	package org.eclipse.hyades.logging.adapter;
2
3	/**********************************************************************	1	/**********************************************************************
4	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2008 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 17-25 Link Here
17	*	15	*
18	**********************************************************************/	16	**********************************************************************/
19		17
		18	package org.eclipse.hyades.logging.adapter;
		19
20	import org.eclipse.hyades.logging.adapter.impl.Status;	20	import org.eclipse.hyades.logging.adapter.impl.Status;
21	import org.eclipse.hyades.logging.adapter.internal.util.Controller;
22	import org.eclipse.hyades.logging.adapter.parsers.PreparationException;	21	import org.eclipse.hyades.logging.adapter.parsers.PreparationException;
		22	import org.eclipse.hyades.logging.adapter.provisional.util.ControllerFactory;
		23	import org.eclipse.hyades.logging.adapter.provisional.util.IController;
		24	import org.eclipse.hyades.logging.adapter.provisional.util.IControllerFactory;
23	import org.eclipse.hyades.logging.adapter.util.AdapterConstants;	25	import org.eclipse.hyades.logging.adapter.util.AdapterConstants;
24	import org.eclipse.hyades.logging.adapter.util.Messages;	26	import org.eclipse.hyades.logging.adapter.util.Messages;
25		27
Lines 54-60 Link Here
54	*/	56	*/
55	public class Adapter {	57	public class Adapter {
56		58
57	private Controller rootController = null;	59
		60	private IControllerFactory controllerFactory;
		61	private IController rootController = null;
58	private String contextFile = null;	62	private String contextFile = null;
59	private String componentFile = null;	63	private String componentFile = null;
60	// Adapter internal log outputter	64	// Adapter internal log outputter
Lines 66-72 Link Here
66	* Status object representing the status of this adapter instance.	70	* Status object representing the status of this adapter instance.
67	*/	71	*/
68	private Status status = new Status();	72	private Status status = new Status();
69		73
		74	/**
		75	* Adapter constructor
		76	*/
		77	public Adapter() {
		78	super();
		79	// Create a controller factory
		80	controllerFactory = new ControllerFactory();
		81
		82	}
70	/**	83	/**
71	* Sets the path of the file containing the context configuration portion of the	84	* Sets the path of the file containing the context configuration portion of the
72	* adapter configuration. This method must be called before the validate and start	85	* adapter configuration. This method must be called before the validate and start
Lines 138-144 Link Here
138	}	151	}
139	// Otherwise create a new controller and load the configuration from the adapter file to validate it.	152	// Otherwise create a new controller and load the configuration from the adapter file to validate it.
140	else {	153	else {
141	rootController = new Controller();	154	rootController = controllerFactory.getController();
142		155
143	if (componentFile == null) {	156	if (componentFile == null) {
144	componentFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile; //$NON-NLS-1$	157	componentFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile; //$NON-NLS-1$
Lines 206-212 Link Here
206	// Otherwise create a new controller and load the configuration from the adapter file.	219	// Otherwise create a new controller and load the configuration from the adapter file.
207	else {	220	else {
208	/* Get a new controller to run the adapter */	221	/* Get a new controller to run the adapter */
209	rootController = new Controller();	222	rootController = controllerFactory.getController();
210		223
211	if (componentFile == null) {	224	if (componentFile == null) {
212	componentFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile; //$NON-NLS-1$	225	componentFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile; //$NON-NLS-1$
Lines 381-387 Link Here
381	}	394	}
382	}	395	}
383	else {	396	else {
384	rootController = new Controller();	397	rootController = controllerFactory.getController();
385		398
386	if (componentFile == null) {	399	if (componentFile == null) {
387	componentFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile; //$NON-NLS-1$	400	componentFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile; //$NON-NLS-1$




/**********************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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
 * $Id: Controller.java,v 1.9 2007/03/22 05:29:24 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 **********************************************************************/

package org.eclipse.hyades.logging.adapter.provisional.util;

/**
 * Implementation of an IControllerFactory that generates Controller instances
 * 
 * @author smith
 *
 */
public class ControllerFactory implements IControllerFactory {

	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.provisional.util.IControllerFactory#getController()
	 */
	public IController getController() {
		// TODO Auto-generated method stub
		return new Controller();
	}

}




/**********************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * 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
 * $Id: Controller.java,v 1.9 2007/03/22 05:29:24 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 * Change History:
 * Bugzilla  Description
 * 79014     Improved error handling and message logging
 * 
 **********************************************************************/
package org.eclipse.hyades.logging.adapter.provisional.util;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.eclipse.hyades.logging.adapter.AdapterException;
import org.eclipse.hyades.logging.adapter.AdapterInvalidConfig;
import org.eclipse.hyades.logging.adapter.AdapterPlugin;
import org.eclipse.hyades.logging.adapter.IComponent;
import org.eclipse.hyades.logging.adapter.IContext;
import org.eclipse.hyades.logging.adapter.IContextListener;
import org.eclipse.hyades.logging.adapter.IOutputter;
import org.eclipse.hyades.logging.adapter.IProcessUnit;
import org.eclipse.hyades.logging.adapter.impl.AdapterContext;
import org.eclipse.hyades.logging.adapter.impl.AdapterXMLConstants;
import org.eclipse.hyades.logging.adapter.impl.Component;
import org.eclipse.hyades.logging.adapter.impl.Context;
import org.eclipse.hyades.logging.adapter.impl.Status;
import org.eclipse.hyades.logging.adapter.internal.util.AdapterConfigValidator;
import org.eclipse.hyades.logging.adapter.internal.util.ComponentFactory;
import org.eclipse.hyades.logging.adapter.internal.util.ContextFactory;
import org.eclipse.hyades.logging.adapter.parsers.PreparationException;
import org.eclipse.hyades.logging.adapter.util.AdapterConstants;
import org.eclipse.hyades.logging.adapter.util.AdapterUtilities;
import org.eclipse.hyades.logging.adapter.util.Messages;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
 * The TPTP implementation of the IController interface.
 * 
 */
public class Controller implements IController {
   
    private boolean singleFileInputMode = false;
    
    /* Keep our contexts and their associated threads within a list. It is imperative that the index
     *  of each list be kept consistent.  That is, the thread running context at index n must be in the
     *  thread list at index n
     */
    private Context[] contexts;
    private Thread[]   contextThreads;
    
  	// Adapter log outputter component
    private IOutputter logOutputter = null;
    
    private String contextConfigurationFile = AdapterConstants.HyadesGADefaultContextConfigurationFile;
    private String componentConfigurationFile = AdapterConstants.HyadesGADefaultComponentConfigurationsFile;
    private DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
    private InputStream inContextParams = null;
    private InputStream inAppParams = null;
    private boolean running = false;
    private long sleepTime = 500;

    // Overall logging level for the Adapter
    private short loggingLevel = -1;
    /**
     * Constructor for Controller.
     */
    public Controller() {
        super();
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#isRunning()
	 */
    public boolean isRunning() {
        return running;
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#start()
	 */
    public void start() {
    	/* RKD:  We will run all of the contexts except the first one 
    	 * (our internal logging context), each in its own thread.
    	 * The internal logging context was already started
    	 * when we went through the prepare stage.
         */
    	synchronized(contexts) {
	        for (int i = 1; i < contextThreads.length; ++i) {
	            if (contexts[i] != null && !contexts[i].isDisabled()) {
	            	contextThreads[i]=new Thread(contexts[i]);
	            	contextThreads[i].setName(contexts[i].getName() + AdapterConstants.HyadesGA + contexts[i].getUniqueID());
	            	contextThreads[i].setDaemon(true);
	            	contextThreads[i].start();
	            }
	        }
    	}
        running = true;
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#stop()
	 */
    public void stop() {

	    if (contexts != null && contextThreads != null) {
	       	synchronized(contexts) {
	       	    int contextStopCount = 0;
	       	    /* stop them in reverse order so that the logging context gets stopped last */        	
	            for (int i=contexts.length-1; i>0; i--) {
	 				/* bugzilla 74713 - set stopping flag instead of calling Context.stop() because
					 * we're running in a different thread than the context.  Also, only stop the
					 * context if the context thread is still alive
					 */
	                if (contexts[i] != null && contextThreads.length > i && contextThreads[i] != null  && contextThreads[i].isAlive()) {
	                    contexts[i].setStopping(true);
	                    contextStopCount++;
	                }
	            }
		        /* If other contexts are stopping Then sleep before stopping 
		         * the logging context to allow the other contexts
	    	     * to log messages and end.
	             * bugzilla 91218 - only sleep if there are contexts in the
	             * process of stopping.
	    		 */
	            if (contextStopCount > 0) {
	            	try {
	            		Thread.sleep(1500);
	            	}
	            	catch (InterruptedException e) {
	            	
	            	}
	            }
	            // Stop the logging context.
	            if (contexts[0] != null && contextThreads.length > 0 && contextThreads[0] != null  && contextThreads[0].isAlive()) {
	                contexts[0].setStopping(true);
	                // Wait until logging context is finished
	                while (contextThreads[0] != null  && contextThreads[0].isAlive()) {
	                	try {
		            		Thread.sleep(200);
		            		// System.out.println("Waited a fifth of a second for logging context to end");
		            	}
		            	catch (InterruptedException e) {
		            	
		            	}
	                }
	            }
	    	}
    	}
        running = false;
    }
    
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#hardStop()
	 */    
	public void hardStop() {
		synchronized(contexts) {
			if (contexts != null && contextThreads != null)
				/* stop them in reverse order so that the logging context gets stopped last */
				for (int i=contexts.length-1; i>=0; i--) {
					/* bugzilla 74713 - set hard stop flag instead of calling Context.stop() because
					 * we're running in a different thread than the context.  Also, only stop the
					 * context if the context thread is still alive
					 */
					if (contexts[i] != null && contextThreads.length > i && contextThreads[i] != null && contextThreads[i].isAlive()) {
						// Set hardStop flag to stop the context
						contexts[i].setHardStop();
					}
				}
		}
		running = false;
	}
    
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#getContexts()
	 */
    public IContext[] getContexts() {
    	synchronized(contexts) {
	    	// Ensure the contexts have been created
	    	if (contexts == null || contexts.length <= 1) {
	    		return null;
	    	}
			// Exclude the internal logging context
			IContext newContextSet[] = new IContext[contexts.length-1];
			for (int i=1; i < contexts.length; i++) {
				newContextSet[i-1] = contexts[i];
			}
			return newContextSet;
    	}
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#setContextConfigPath(java.lang.String)
	 */
    public void setContextConfigPath(String config) {
        contextConfigurationFile = config;
    }
    
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#getContextConfigPath()
	 */
	public String getContextConfigPath() {
		return contextConfigurationFile;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#setComponentConfigPath(java.lang.String)
	 */
    public void setComponentConfigPath(String config) {
        componentConfigurationFile = config;
    }

    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#getComponentConfigPath()
	 */
	public String getComponentConfigPath() {
		return componentConfigurationFile;
	}

    /*
     * Validates an adapter file against the schema files.
     */
    private void validateAdapterConfigurations(InputStream inAppStream, IProcessUnit logger) throws AdapterInvalidConfig {
    	AdapterConfigValidator validator = new AdapterConfigValidator(logger);
    	try{
    		validator.validate(inAppStream);
    	}catch(AdapterException e){    		
    		log(e.toString());
    	}    	
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#prepareAdapter(boolean)
	 */
    public void prepareAdapter(boolean validating) throws AdapterException {
    	/* Open the context and configuration files */
        try {
    		inContextParams = new FileInputStream(contextConfigurationFile);
    		if (singleFileInputMode) {
    			inAppParams = new FileInputStream(contextConfigurationFile);
    		}
    		else {
    			inAppParams = new FileInputStream(componentConfigurationFile);
    		}
    	}
    	catch(FileNotFoundException e) {
    		String filename=null;
    		if(inContextParams==null) {
    			filename=contextConfigurationFile;
    		}
    		else {
    			filename=componentConfigurationFile;
    			try {
    				inContextParams.close();
    			}
    			catch(IOException eprime) {
    				/* We will ignore if this fails.  It should be successful as we just opened the file */
    			}	
    		}
        	/* We cannot open the adapter file */
        	throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Open_ERROR_", filename));
    	}
    	catch (Throwable e) {
     		String filename=null;
    		if(inContextParams==null) {
    			filename=contextConfigurationFile;
    		}
    		else {
    			filename=componentConfigurationFile;
    			try {
    				inContextParams.close();
    			}
    			catch(IOException eprime) {
    				/* We will ignore if this fails.  It should be successful as we just opened the file */
    			}	
    		}
        	/* We cannot open the adapter file */
        	throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Open_ERROR_", filename),e);
    	}
        
        // build the contexts based on configurations     	
        try {
        	contexts = createContextsAndComponents(inContextParams);
        	synchronized(contexts) {
        		setComponentConfigurations(inAppParams);
        	}
	        
	        /* We are done with the files.  Lets close them */
	        try {
	        	inContextParams.close();
	        	if(!singleFileInputMode) {
	        		inAppParams.close();
	        	}	
	        }
	        catch(IOException e) {
	        	/* We just had the file open. We are now closing it */
	        }

            /* Before we start the contexts locate any IContextListeners that
             * are registered with the plugin.  This only works when we are running
             * as a plugin inside of Eclipse.  Outside of Eclipse there is no notion
             * of IContextListeners.
             */
	        if (AdapterUtilities.isWorkbench()) {
	            try {
	                List contextListeners = AdapterPlugin.getContextListeners();
	
	                /* If this context has a listener then set it */
	                if (contextListeners != null) {
	                    Iterator listenerIterator = contextListeners.iterator();
	                    while (listenerIterator.hasNext()) {
	                        IContextListener listener = (IContextListener) listenerIterator.next();
	                        String[] targetContexts = listener.getTargetContextUniqueIds();
	                        for (int j = 0; j < targetContexts.length; j++) {
	                            for (int k = 0; k < contexts.length; k++) {
	                                if (contexts[k].getUniqueID().equals(targetContexts[j])) {
	                                    contexts[k].setContextListener(listener);
	                                }
	                            }
	                        }
	                    }
	                }
	            }
	            catch (AdapterException e) {
	            	throw e;
	            }
	            catch (Throwable e) {
	                throw new AdapterException(Messages.getString("HyadesGAInitialization_GetContextListeners_Failure_ERROR_"), e);
	            }
	        }
            
            /* Start the logging context in its entirty before we continue with anything else */
            IProcessUnit logger=startInternalLoggingContext();

            /* Validate the adapter configuration file against the schema files before starting the rest of the contexts.  
             * It would have been good to have done this above, however, we want our internal logging context running so that we 
             * can report any errors during validation
             */            
            inAppParams = new FileInputStream(contextConfigurationFile);
            validateAdapterConfigurations(inAppParams, logger);
 
            if (!singleFileInputMode) {
                inAppParams = new FileInputStream(componentConfigurationFile);
                validateAdapterConfigurations(inAppParams, logger);
            }
            
            // Count the number of contexts that are initialized and ready to execute
            int contextsReadyCount = 0;
            AdapterException initException = null;
            
            synchronized(contexts) {
	            for (int i = 1; i < contexts.length; ++i) {
	                if (contexts[i] != null) {
	                	
	                	/* Set the logger for this context to be the internal logging sensor */
	                	contexts[i].setLogger(logger);
	                	
	                	/* Set the validating status for the context */
	                	contexts[i].setValidating(validating);
	                	
	                	/* bugzilla 96433
	                	 * Set logging level of context and components if it needs to be globally set
	                	 * and it is not being validated.
	                	 */ 
	                	if (!validating && loggingLevel > -1) {
	                		contexts[i].setLoggingLevel(loggingLevel);
	                		IComponent comp[] = contexts[i].getComponents();
	                		for (int j=0; j<comp.length; j++) {
	                			comp[j].setLoggingLevel(loggingLevel);
	                		}
	                	}
	                	
	                    // set all the context config info
	                    if (!(contexts[i].init())) {
	                    	contexts[i]=null;
	                    	/* Make sure we log that this context will not be started */
	                    	log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	continue;
	                    }
	                    // set all the component config info
	                    
	                    /* Setup the configuration information for this context.  At this point in time the context
	                     * may fail to initialize itself properly.  If that is the case then this context should be 
	                     * disabled.
	                     */
	                    try {
	                    	contexts[i].update();
	                    	// Only increment context ready count if context is not disabled
	                    	if (!contexts[i].isDisabled()) {
	                    		contextsReadyCount++;
	                    	}
	                    }
	                    catch(AdapterException e) {
	                    	if (!validating) {
	                    		contexts[i]=null;
	                    		/* Make sure we log that this context will not be started */
	                    		log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	}
	                    	initException = e;
	                    }
	                }
	            }
            }
            // If there are no contexts ready to execute then quit! 
            if (contextsReadyCount == 0) {
            	if (initException != null) {
            		throw initException;
            	}
            	else {
            		throw new AdapterException(Messages.getString("HyadesGAContextFatal_ERROR_"));
            	}
            }
        }   
        catch(Throwable e) {
        	/* RKD:  Our caller will need to use our exception information for now to handle the error.*/
			/* Don't log anything here.  Assume the caller handles the exception and 
			 * logs a message if necessary.
             * log(Messages.getString("HyadesGAAdapterFatal_ERROR_"));
          	 * log(e.toString());
			 */
        	if (e instanceof AdapterException) {
        		throw (AdapterException)e;
        	}
        	
        	// Wrap non-AdapterException in an AdapterException
        	String errorMsg = e.getMessage();
        	if (errorMsg == null) {
        	 	errorMsg = e.toString();
        	}
            throw new AdapterException(errorMsg);
        }
        finally {
        	
        	/* Close our configuration file */
            try {
                if (inAppParams != null) {
                	inAppParams.close();
                }
                if (inContextParams != null) {
                	inContextParams.close();
                }
            }
            catch (IOException e) {
            	/* We couldn't close the configuration files.  This should only occur if we failed to 
            	 * open the file in the first place.
            	 */
                log(e.toString());
            }
        }
    }
 
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#prepareConfiguration(boolean)
	 */
    public void prepareConfiguration(boolean validating) throws AdapterException {
  	
        try {            
            /* Start the logging context in its entirty before we continue with anything else */
            IProcessUnit logger=startInternalLoggingContext();

            // Count the number of contexts that are initialized and ready to execute
            int contextsReadyCount = 0;
            AdapterException initException = null;
            
            synchronized(contexts) {
	            for (int i = 1; i < contexts.length; ++i) {
	                if (contexts[i] != null) {
	                	
	                	/* Set the logger for this context to be the internal logging sensor */
	                	contexts[i].setLogger(logger);
	                	
	                	/* Set the validating status for the context */
	                	contexts[i].setValidating(validating);
	                	
	                	/* bugzilla 96433
	                	 * Set logging level of context and components if it needs to be globally set
	                	 * and it is not being validated.
	                	 */ 
	                	if (!validating && loggingLevel > -1) {
	                		contexts[i].setLoggingLevel(loggingLevel);
	                		IComponent comp[] = contexts[i].getComponents();
	                		for (int j=0; j<comp.length; j++) {
	                			comp[j].setLoggingLevel(loggingLevel);
	                		}
	                	}
	                	
	                    // set all the context config info
	                    if (!(contexts[i].init())) {
	                    	contexts[i]=null;
	                    	/* Make sure we log that this context will not be started */
	                    	log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	continue;
	                    }
	                    // set all the component config info
	                    
	                    /* Setup the configuration information for this context.  At this point in time the context
	                     * may fail to initialize itself properly.  If that is the case then this context should be 
	                     * disabled.
	                     */
	                    try {
	                    	contexts[i].update();
	                    	// Only increment context ready count if context is not disabled
	                    	if (!contexts[i].isDisabled()) {
	                    		contextsReadyCount++;
	                    	}
	                    }
	                    catch(AdapterException e) {
	                    	if (!validating) {
	                    		contexts[i]=null;
	                    		/* Make sure we log that this context will not be started */
	                    		log(Messages.getString("HyadesGAContextFatal_ERROR_"));
	                    	}
	                    	initException = e;
	                    }
	                }
	            }
            }
            // If there are no contexts ready to execute then quit! 
            if (contextsReadyCount == 0) {
            	if (initException != null) {
            		throw initException;
            	}
            	else {
            		throw new AdapterException(Messages.getString("HyadesGAContextFatal_ERROR_"));
            	}
            }
        }   
        catch(Throwable e) {
        	/* RKD:  Our caller will need to use our exception information for now to handle the error.*/
			/* Don't log anything here.  Assume the caller handles the exception and 
			 * logs a message if necessary.
             * log(Messages.getString("HyadesGAAdapterFatal_ERROR_"));
          	 * log(e.toString());
			 */
        	if (e instanceof AdapterException) {
        		throw (AdapterException)e;
        	}
        	
        	// Wrap non-AdapterException in an AdapterException
        	String errorMsg = e.getMessage();
        	if (errorMsg == null) {
        	 	errorMsg = e.toString();
        	}
            throw new AdapterException(errorMsg);
        }

    }
    
    /**
     * parses Context configurations and build the Context objects
     * as well as set teh context config for each component
     */
    private Context[] createContextsAndComponents(InputStream inContextStream) throws PreparationException {

        Document doc = null;
        Context[] contexts = null;
        try {
            doc = docFactory.newDocumentBuilder().parse(inContextStream);

            //Add the adapter logging context as default:
            Element loggingContext = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXT);
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Context instance for the current component");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.impl.AdapterContext");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "60");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, AdapterXMLConstants.HyadesGAAdapterContextName);
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "context");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingContext.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NB1F4ED002DA11D8A519FBE7C98C2F53");

            Element loggingSensor = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter logging sensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.AdapterSensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            // bugzilla 84698 - If there is an outputter Then let WARNING or higher messages be logged.
            if (logOutputter != null) {
            	loggingSensor.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
            }
            // Otherwise let all messages be logged
            else {
            	loggingSensor.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "0");
            }
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogSensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "sensor");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingSensor.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NF991E0004FF11D8930381B6A308BEB5");

            loggingContext.appendChild(loggingSensor);

            Element loggingOutputter = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter logging outputter");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionAttributeName, "");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionDescriptionAttributeName, "");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "outputter");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
            loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");

            // Add the outputter specified by the user (eg. set by StaticParserWrapper in the log import case)
            if (logOutputter != null) {
            	//Set the logging level so we get Warning, Critical and Fatal error messages
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, logOutputter.getClass().getName());
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogOutputter");
                
                /*************************************************************************************************                
                 * bugzilla 79014 
                 * Comment this out because we should not need to log to a file in the log import
                 * case.  GLA messages will be handled by the outputter set by the user.
                 * However, we'll keep the code here in case we find it necessar to log to a file as well.              
                 *                  
                 * loggingContext.appendChild(loggingOutputter);
                 *               
                 * // Create a file outputter too
                 * loggingOutputter = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter File logging outputter");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionAttributeName, "");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAImplementationVersionDescriptionAttributeName, "");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleAttributeName, "outputter");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGARoleCreationDateAttributeName, "Fri Jan 09 15:27:17 EST 2004");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "AdapterFileLoggerId");
                 * //Set the logging level so we get Warning, Critical and Fatal error messages
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.AdapterLogFileOutputter");
                 * loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogFileOutputter");
                 *
                 **************************************************************************************************/
            }
	        //Add the Eclipse Problems View outputter if in Eclipse mode. This is used when the context runs in the GLA editor.
	        else if (AdapterUtilities.isWorkbench()) {
            	//Set the logging level so we get any messages that are at least informational
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "10");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.GlaTaskOutputter");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "CBEEclipseProblemsViewOutputter");
            }
            //Add the log file outputter if in standalone mode:
            else {
            	//Set the logging level so we get Warning, Critical and Fatal error messages
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGALoggingLevelAttributeName, "30");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName, "org.eclipse.hyades.logging.adapter.internal.util.AdapterLogFileOutputter");
                loggingOutputter.setAttribute(AdapterXMLConstants.HyadesGANameAttributeName, "AdapterLogFileOutputter");                
            }      

            loggingContext.appendChild(loggingOutputter);

            NodeList contextsNodeList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTS);

            if (contextsNodeList.getLength() == 0) {

                //Create a contexts element:	
                Element contextsElement = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTS);
                
                /* Insert the logging context at the first of the child list of elements */
                NodeList children=contextsElement.getChildNodes();
                for(int i=0; i<children.getLength(); i++) {
                	if(children.item(i).getNodeType()==Node.ELEMENT_NODE) {
                		contextsElement.insertBefore(loggingContext, children.item(i));
                		break;
                	}	
                }

                doc.getDocumentElement().appendChild(contextsElement);
            }
            else {

                //ASSUMPTION:  Only one contexts element permitted.	

                //Retrieve the contexts element:	
                Node contextsElement = contextsNodeList.item(0);
                /* Insert the logging context at the first of the child list of elements */
                NodeList children=contextsElement.getChildNodes();
                for(int i=0; i<children.getLength(); i++) {
                	if(children.item(i).getNodeType()==Node.ELEMENT_NODE) {
                		contextsElement.insertBefore(loggingContext, children.item(i));
                		break;
                	}	
                }

                doc.getDocumentElement().appendChild(contextsElement);
            }

            try {
                NodeList contextList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXT);
                // check to see if this file contains everything or just the context config
                NodeList tempInstanceList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);
                if (tempInstanceList.getLength() > 0)
                    singleFileInputMode = true;
                else
                    singleFileInputMode = false;
                int count = contextList.getLength();
                contexts = new Context[count];
                int j = 0;
                Element element = null;
                Context context = null;
                Component component = null;
                
                for (int i = 0; i < count; ++i) {
                    //TODO: HS need to support imbedded/nested contexts/components
                    // Extract each root context and copy the expected attributes
                    element = (Element) contextList.item(i);
                	/* try and build the context.  A number of things can go wrong here as we use relection to build the instance. */
                	context = ContextFactory.buildContext(element.getAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGANameAttributeName));	
                	context.setContextConfiguration(element);

                    //
                    // get a list of all sub elements and assume they are components
                    NodeList componentList = element.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_COMPONENT);
                    IComponent[] compArray = null;
                    int componentCount = componentList.getLength();
                    compArray = new IComponent[componentCount];
                    for (int k = 0, l = 0; k < componentCount; k++) {
                        // Extract each component config
                        element = (Element) componentList.item(k);

                        // Check if we have a log outputter object already and if so then use that
                        if (i == 0 && k ==1 && logOutputter != null) {
                        	component = (Component)logOutputter;
                        	component.setName(element.getAttribute(AdapterXMLConstants.HyadesGANameAttributeName));
                        	component.setUniqueID(element.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName));
                        	component.setExecutableClassName(element.getAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName));
                        }
                        else {
                        	component = ComponentFactory.buildComponent(element.getAttribute(AdapterXMLConstants.HyadesGAExecutableClassAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName), element.getAttribute(AdapterXMLConstants.HyadesGANameAttributeName));
                        }
                        component.setContextConfiguration(element);
                        compArray[l++] = component;
                    }
                    // put the components in the context
                    context.setComponents(compArray);
                    // put this context in the controller's array
                    contexts[j++] = context;
                }
            }
            catch (PreparationException e) {
                throw e;
            }
            catch (Exception e) {
                throw new PreparationException(Messages.getString("HyadesGAInitialization_ContextConfiguration_Failure_ERROR_", contextConfigurationFile), e);
            }
        }
        catch (SAXException e) {
        	/* We have a problem parsing the configuration file ABORT */
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", contextConfigurationFile), e);
        }
        catch (ParserConfigurationException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", contextConfigurationFile), e);
        }
        catch (IOException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", contextConfigurationFile), e);
        }
        return contexts;
    }

    /**
     * CreateContextsConfig takes in an entire component configurations file and
     * separates out the context instances and gives each context the sub tree for itself and
     * it's components.
     */
    private void setComponentConfigurations(InputStream inAppStream) throws AdapterInvalidConfig, PreparationException {

        Document doc = null;

        try {

            doc = docFactory.newDocumentBuilder().parse(inAppStream);

            //Add the adapter internal logging context instance as default:
            Element loggingSensorInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_SENSOR);
            loggingSensorInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "An adapter CBE sensor");
            loggingSensorInstance.setAttribute(AdapterXMLConstants.HyadesGAmaximumBlockingAttributeName, "5");
            loggingSensorInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NF991E0004FF11D8930381B6A308BEB5");

            Element loggerContextInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);
            loggerContextInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Context instance for the current component");
            /* Configure the internal logging context to run forever or until the adatper is explicitly stopped */ 
            loggerContextInstance.setAttribute(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_CONTINUOUS_OPERATION, "true");
            loggerContextInstance.setAttribute(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_MAXIMUM_IDLE_TIME, "0");
            loggerContextInstance.setAttribute(AdapterXMLConstants.CONTEXTINSTANCE_ATTR_NAME_PAUSE_INTERVAL, "10");
            loggerContextInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "NB1F4ED002DA11D8A519FBE7C98C2F53");

            loggerContextInstance.appendChild(loggingSensorInstance);

            // Configure the log outputter for the log import case
            if (logOutputter != null) {
				Element loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Adapter log outputter");
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");
				
				/* This outputter is created and configured by the user so there will not be any configuration properties for it. */
				
                loggerContextInstance.appendChild(loggingOutputterInstance);
                
                /*************************************************************************************************                
                 *              bugzilla 79014 
                 *              Comment this out because we should not need to log to a file in the log import
                 *              case.  GLA messages will be handled by the outputter set by the user.
                 *              However, we'll keep the code here in case we find it necessary to log to a file as well.              
                 *   
                 *              // Get the directory for the GLA log file
                 *              String glaLogDirectory = ".";
                 *       		try {
                 *       			
                 *       			// Try to get the plugin's workspace directory (e.g. <workspace>/.metadata/plugins/org.eclipse.hyades.logging.adapter) 
                 *
                 *       			Class platformClass = Class.forName("org.eclipse.core.runtime.Platform");
                 *       			
                 *       			Method getPluginStateLocationMethod = platformClass.getMethod("getPluginStateLocation",new Class[]{Class.forName("org.eclipse.core.runtime.Plugin")});
                 *       			
                 *       			Object iPathObject =  getPluginStateLocationMethod.invoke(null,new Object[]{AdapterPlugin.getPlugin()});
                 *       			
                 *       			Class iPathClass = iPathObject.getClass();
                 *       			
                 *       			Method toOSStringMethod = iPathClass.getMethod("toOSString",null);
                 *       			
                 *       			glaLogDirectory = (String)(toOSStringMethod.invoke(iPathObject,null));
                 *       		}
                 *       		catch (Exception e) {
                 *       			// Ignore this and use the current directory for the GLA log file
                 *       		}
                 *       		
                 *               // Add the file logger component configuration
                 *               loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
                 *               loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Single file outputter");
                 *               loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "AdapterFileLoggerId");
                 *
                 *				 Element outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
                 *               outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, glaLogDirectory);
                 *				 outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAdirectoryAttributeName);
                 *               loggingOutputterInstance.appendChild(outputterProperty);
                 *               
                 *				 outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
                 *				 outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, "hgla.log");
                 *				 outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAfileNameAttributeName);
                 *				 loggingOutputterInstance.appendChild(outputterProperty);                
                 *				
                 *               loggerContextInstance.appendChild(loggingOutputterInstance);
                 * 
                 ************************************************************************************/	
            }
            // Configure the Problems View outputter for the GLA editor case
            else if (AdapterUtilities.isWorkbench()) {
            	
				Element loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Eclipse error dialog outputter");
				loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");
				
				/* RKD:  We need to inform the outputter of the configuration path so it can create markers for the resource */
		        Element resourcePathProperty=doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
	            resourcePathProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName, "resourceName");
	            resourcePathProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, contextConfigurationFile);
	                
	            loggingOutputterInstance.appendChild(resourcePathProperty);
                loggerContextInstance.appendChild(loggingOutputterInstance);			
            }
            else{

                Element loggingOutputterInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_OUTPUTTER);
                loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "Single file outputter");
                loggingOutputterInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N5F286A002DA11D8BC799C6AF4352915");

				Element outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, ".");
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAdirectoryAttributeName);
                loggingOutputterInstance.appendChild(outputterProperty);
                
				outputterProperty = doc.createElement(AdapterXMLConstants.HyadesGAPropertyElementTagName);
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyValueAttributeName, "hgla.log");
				outputterProperty.setAttribute(AdapterXMLConstants.HyadesGAPropertyNameAttributeName,AdapterXMLConstants.HyadesGAfileNameAttributeName);
				loggingOutputterInstance.appendChild(outputterProperty);                
				
                loggerContextInstance.appendChild(loggingOutputterInstance);
            }

            NodeList configurationNodeList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONFIGURATION);

            if (configurationNodeList.getLength() == 0) {

                //Create a configuration element:	
                Element loggerConfigurationInstance = doc.createElement(AdapterXMLConstants.ELEMENT_TAG_NAME_CONFIGURATION);
                loggerConfigurationInstance.setAttribute(AdapterXMLConstants.HyadesGADescriptionAttributeName, "The component level configurations for this adapter");
                loggerConfigurationInstance.setAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName, "N06FBD3004FF11D8BCF4CFA9EA8F31E7");

                loggerConfigurationInstance.appendChild(loggerContextInstance);

                doc.getDocumentElement().appendChild(loggerConfigurationInstance);
            }
            else {

                //ASSUMPTION:  Only one configuration element permitted.	

                //Retrieve the configuration element:	
                Node loggerConfigurationInstance = configurationNodeList.item(0);
                loggerConfigurationInstance.appendChild(loggerContextInstance);

                doc.getDocumentElement().appendChild(loggerConfigurationInstance);
            }

            try {
                // get a list of all the context instances and associates each with a context
                NodeList contextInstanceList = doc.getElementsByTagName(AdapterXMLConstants.ELEMENT_TAG_NAME_CONTEXTINSTANCE);

                int contextInstanceCount = contextInstanceList.getLength();
                for (int i = 0; i < contextInstanceCount; ++i) {
                    try {
                        //find the matching Context and Context Instance
                        Element contextElement = (Element) contextInstanceList.item(i);
                        String contextInstanceID = contextElement.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName);

                        int contextCount = contexts.length;
						/* Throw an exception if we have a mismatch in the number of Context's and
						 * the number of ContextInstance's.
						 */
						if (contextInstanceCount != contextCount) {
							throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextConfigurationErrorContextCountMismatchFatal_ERROR_"));
						}                       
                        
                        boolean contextFound = false;
                        for (int j = 0; j < contextCount; j++) {
                            if (contexts[j].getUniqueID().equals(contextInstanceID)) {
                                contexts[j].setConfiguration(contextElement);
                                contextFound = true;
                                // so now we have a good context which may or may not have components
                                //assume each child of the contextInstance is a component
                                NodeList componentInstanceList = contextElement.getChildNodes();
                                int numberOfComponentInstances = componentInstanceList.getLength();
                                // get the components from the context
								IComponent components[] = contexts[j].getComponents();
								int componentCount = components.length;

								int componentInstanceCount = 0;
                                for (int k = 0; k < numberOfComponentInstances; k++) {
                                    if (componentInstanceList.item(k).getNodeType() == Node.ELEMENT_NODE) {
                                        Element componentElement = (Element) componentInstanceList.item(k);
                                        String componentInstanceID = componentElement.getAttribute(AdapterXMLConstants.HyadesGAUniqueIDAttributeName);
                                        boolean componentFound = false;
                                        componentInstanceCount++;
                                        // walk through the components of the context and set the config
                                        for (int l = 0; l < componentCount; l++) {
                                            if (components[l].getUniqueID().equals(componentInstanceID)) {
                                                components[l].setConfiguration(componentElement);
                                                componentFound = true;
                                                /* bugzilla 82193
                                                 * If this is a formatter and we are running in the GLA editor
                                                 */
                                                if (componentElement.getNodeName().equals(AdapterXMLConstants.ELEMENT_TAG_NAME_FORMATTER) && 
                                                		logOutputter == null &&	AdapterUtilities.isWorkbench()) {
                                                	/* Add the test attribute to the formatter element to indicate we are running
                                                	 * in the GLA editor environment.  
                                                	 */
                                                	componentElement.setAttribute(AdapterConstants.AttrubuteName_Test,AdapterConstants.AttrubuteValue_Test_True);
                                                }
                                                break;
                                            }
                                        }
                                        if (!componentFound) {
											throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextInstanceConfigurationErrorComponentIdNotFoundFatal_ERROR_",componentInstanceID , contexts[j].getUniqueID()));
                                        }
                                    }
                                }
								/* Throw an exception if we have a mismatch in number of components between
								 * the context and the contextInstance.
								 */
								if (componentInstanceCount != componentCount) {
									throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextInstanceConfigurationErrorComponentMismatchFatal_ERROR_",contexts[j].getUniqueID()));
								}
                                break;
                            }
                        }
						if (!contextFound) {
							throw new AdapterInvalidConfig(Messages.getString("HyadesGAContextInstanceConfigurationErrorContextIdNotFoundFatal_ERROR_", contextInstanceID));
						}
                    }
                    catch (AdapterInvalidConfig e) {
                    	throw e;
                    }
                    catch (Exception e) {
                        throw new PreparationException(Messages.getString("HyadesGAInitialization_ContextInstanceConfiguration_Failure_ERROR_", componentConfigurationFile), e);
                    }
                }
            }
            catch (AdapterInvalidConfig e) {
            	throw e;
            }
            catch (Exception e) {
                throw new PreparationException(Messages.getString("HyadesGAInitialization_ContextInstanceConfiguration_Failure_ERROR_", componentConfigurationFile), e);
            }
        }
        catch (SAXException e) {
        	/* We have a problem parsing the configuration file ABORT */
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", componentConfigurationFile), e);
        }
        catch (ParserConfigurationException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", componentConfigurationFile), e);
        }
        catch (IOException e) {
            throw new PreparationException(Messages.getString("HyadesGA_CBE_Adapter_Config_File_Parse_ERROR_", componentConfigurationFile), e);
        }
    }
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#run()
	 */
    public void run() {
        start();
        while (isRunning()) {
            synchronized (this) {
                try {
                    wait(sleepTime);
                }
                catch (Exception e) {
                    log(e.toString());
                }
                if (areContextsDone()) {
               	    // Stop the Adapter logging context
                    stop();
                }
            }
        }
    }
    /**
     * return false if any context is still alive, otherwise return true 
     */
    private boolean areContextsDone() {
        if (contextThreads != null) {
        	/* Ignore the internal logging context.  hense we start at index 1 */
            for (int i = 1; i < contextThreads.length; i++) {
                if (contextThreads[i] != null) {
                    if (contextThreads[i].isAlive() && !(contexts[i] instanceof AdapterContext))
                        return false;
                }
            }
        }
        return true;
    }
    
    /**
     * clean a controller by nulling out everything
     */
    private void clean() {
        if (contexts != null) {
            for (int i = 0; i < contexts.length; i++) {
                contexts[i] = null;
            }
        }
        contexts = null;
        //		hashContextConfig.clear();
    }
    
    /**
     * Starts the internal logging context.
     *
     */
    private IProcessUnit startInternalLoggingContext() {
    	contexts[0].init();
    	contextThreads=new Thread[contexts.length];
        try {
        	contexts[0].update();
        	// bugzilla 96433 - Reset the logging context status
        	contexts[0].setStopping(false);
        	contextThreads[0]=new Thread(contexts[0]);
        	contextThreads[0].setName(contexts[0].getName() + AdapterConstants.HyadesGA + contexts[0].getUniqueID());
        	contextThreads[0].setDaemon(true);
        	contextThreads[0].start();
        	return (IProcessUnit)contexts[0].getComponents()[0];
        	
        }
        catch(AdapterException e) {
        	/* Since we are generating the context content we should not have configuration problems */
        	/* However, we may get an exception here if the GLA logging cannot be initialized. */
			log(Messages.getString("HyadesGAInitialization_Internal_Logging_Not_Started_WARN_", e.getLocalizedMessage()));
        }
        catch(Exception e) {
        	/* Catch any other kind of exception and log a message */
        	log(Messages.getString("HyadesGAInitialization_Internal_Logging_Not_Started_WARN_", e.toString()));
        }
        return null;
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#log(java.lang.String)
	 */
    public void log(String logRecord) {
    	if(!AdapterUtilities.isWorkbench()) {
    		System.err.println(logRecord);
    	}
       
    }
    
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#getStatus()
	 */
    public Status [] getStatus() {
    	Status [] statuses = null; 
    	
    	/* If there are context then get their status */
	    if (contexts != null) {
	    	synchronized(contexts) {
	        	statuses = new Status[contexts.length];
	        	/* get the status for each context */        	
	            for (int i=0; i < contexts.length; i++) {
	            	if (contexts[i] != null) {
	            		statuses[i] = contexts[i].getContextStatus();
	            	}
	            	else {
	            		statuses[i] = null;
	            	}
	            }
	        }
    	}
    	
    	return statuses;
    }
	
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#getLogOutputter()
	 */
	public IOutputter getLogOutputter() {
		return logOutputter;
	}
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#setLogOutputter(org.eclipse.hyades.logging.adapter.IOutputter)
	 */
	public void setLogOutputter(IOutputter logOutputter) {
		this.logOutputter = logOutputter;
	}
	
    /* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#setLoggingLevel(short)
	 */
	public void setLoggingLevel(short newLevel)
	{
		loggingLevel = newLevel;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.hyades.logging.adapter.internal.util.IController#getLoggingLevel()
	 */
	public short getLoggingLevel() {
		return loggingLevel;
	}
}




/**********************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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
 * $Id: Controller.java,v 1.9 2007/03/22 05:29:24 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 **********************************************************************/

package org.eclipse.hyades.logging.adapter.provisional.util;

import org.eclipse.hyades.logging.adapter.AdapterException;
import org.eclipse.hyades.logging.adapter.IContext;
import org.eclipse.hyades.logging.adapter.IOutputter;
import org.eclipse.hyades.logging.adapter.impl.Status;

/**
 * This interface represents a Controller that manages a set of Context 
 * objects by setting the configurations and then starting each context.
 * 
 * @author dnsmith
 */

public interface IController extends Runnable {

	/**
	 * Returns whether the Controller is running.
	 * @return true if Controller is running, false otherwise
	 */
	public boolean isRunning();

	/**
	 * Start running the controller which means starting up each of the contexts.
	 */
	public void start();

	/**
	 * Stop the controller which means stopping all of the contexts if they
	 * are still running.
	 */
	public void stop();

	/**
	 * This stop method will still cause the contexts to be stopped but will
	 * not call the context listener methods when flushing the components.
	 */
	public void hardStop();

	/**
	 * Get the set of Context objects
	 * @return the set of Context objects
	 */
	public IContext[] getContexts();

	/**
	 * Set the name of the file containing the configurations for the
	 * contexts.
	 * @param config - name of the context configuation file
	 */
	public void setContextConfigPath(String config);

	/**
	 * Get the name of the file containing the configurations for the contexts
	 * @return the contextConfigurationFile
	 */
	public String getContextConfigPath();

	/**
	 * Set the name of the file containing the configurations for the
	 * components of the contexts.
	 * @param config - name of the component configuation file
	 */
	public void setComponentConfigPath(String config);

	/**
	 * Get the name of the file containing the configurations for the components of the contexts.
	 * @return the componentConfigurationFile
	 */
	public String getComponentConfigPath();

	/**
	 * Prepare the adapter for execution.  This involves reading and validating the adapter 
	 * configuration file(s), getting the context listeners from eclipse, starting the internal
	 * logging context, and initializing the contexts.
	 * @param validating  boolean flag to indicate this method is called as part of adapter validation
	 */
	public void prepareAdapter(boolean validating) throws AdapterException;

	/**
	 * Prepare the adapter configuration for execution.  This involves 
	 * starting the internal logging context, and initializing the contexts.
	 * @param validating  boolean flag to indicate this method is called as part of adapter validation
	 */
	public void prepareConfiguration(boolean validating)
			throws AdapterException;

	/**
	 * run provides the basic loop for a Controller thread.  It starts the Controller thread and
	 * then monitors it.

	public void run();
	 */
	/**
	 * Log the string message to standard error since the logging outputter(s)
	 * associated with the <code>AdapterSensor</code> logger will never be
	 * started.
	 * 
	 * @param logRecord The string message to be logged to standard error.
	 */
	public void log(String logRecord);

	/**
	 * Get the status of the contexts
	 * @return the array of Status objects representing the status of the contexts
	 */
	public Status[] getStatus();

	/**
	 * Get the custom Outputter that the internal logging context is using.
	 * @return Returns the custom Outputter that the internal logging context is using.
	 */
	public IOutputter getLogOutputter();

	/**
	 * Sets the custom Outputter for the internal logging context to use.
	 * @param logOutputter The custom Outputter for the internal logging context.
	 */
	public void setLogOutputter(IOutputter logOutputter);

	/**
	 * Sets the loggingLevel of the Adapter object.  This value will override 
	 * all values in the adapter configuration. The logging level value specified will
	 * take effect the next time the Adapter is started. If this method is 
	 * not called or is called with a value of -1, the logging levels specified in the
	 * adapter configuration will be used.
	 * @param newLevel The level of logging that the Adapter will use during execution
	 */
	public void setLoggingLevel(short newLevel);

	/**
	 * Get the logging level of the Adapter object.
	 * @return the level of logging the Adapter is currently using
	 */
	public short getLoggingLevel();

}




/**********************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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
 * $Id: Controller.java,v 1.9 2007/03/22 05:29:24 dnsmith Exp $
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 * 
 **********************************************************************/

package org.eclipse.hyades.logging.adapter.provisional.util;

/**
 * This interface represents a factory to create IController instances.
 * 
 * @author dnsmith
 *
 */
public interface IControllerFactory {

	/**
	 * Gets an instance of an IController class
	 * @return IController instance
	 */
	public IController getController();
	
}

Lines 1-5 Link Here

(-)cbe.import/org/eclipse/tptp/monitoring/log/internal/core/RemoteImportHandler.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 44-50 Link Here
44	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;	44	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;
45	import org.eclipse.hyades.logging.parsers.importer.ILogParser;	45	import org.eclipse.hyades.logging.parsers.importer.ILogParser;
46	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	46	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
47	import org.eclipse.hyades.logging.parsers.internal.importer.LocalLogImportLoader;	47	import org.eclipse.hyades.logging.parsers.provisional.importer.LocalLogImportLoader;
48	import org.eclipse.hyades.models.hierarchy.TRCAgent;	48	import org.eclipse.hyades.models.hierarchy.TRCAgent;
49	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;	49	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;
50	import org.eclipse.hyades.models.hierarchy.TRCProcessProxy;	50	import org.eclipse.hyades.models.hierarchy.TRCProcessProxy;

Lines 1-5 Link Here

(-)cbe.import/org/eclipse/tptp/monitoring/log/internal/core/ImportLogHelper.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005,2007 IBM Corporation and others.	2	* Copyright (c) 2005,2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 46-52 Link Here
46	import org.eclipse.hyades.logging.parsers.adapter.sensors.StaticParserSensor;	46	import org.eclipse.hyades.logging.parsers.adapter.sensors.StaticParserSensor;
47	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	47	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
48	import org.eclipse.hyades.logging.parsers.internal.adapter.outputters.CBEtoCSVOutputter;	48	import org.eclipse.hyades.logging.parsers.internal.adapter.outputters.CBEtoCSVOutputter;
49	import org.eclipse.hyades.logging.parsers.internal.importer.GLAHelper;	49	import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
50	import org.eclipse.hyades.models.hierarchy.TRCAgent;	50	import org.eclipse.hyades.models.hierarchy.TRCAgent;
51	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;	51	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;
52	import org.eclipse.hyades.models.hierarchy.util.IHyadesResourceExtension;	52	import org.eclipse.hyades.models.hierarchy.util.IHyadesResourceExtension;

Lines 1-5 Link Here

(-)cbe.import/org/eclipse/tptp/monitoring/log/internal/core/AbstractImportHandler.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 17-23 Link Here
17	import java.util.Map;	17	import java.util.Map;
18		18
19	import org.eclipse.core.runtime.IStatus;	19	import org.eclipse.core.runtime.IStatus;
20	import org.eclipse.hyades.logging.parsers.internal.importer.LocalLogImportLoader;	20	import org.eclipse.hyades.logging.parsers.provisional.importer.LocalLogImportLoader;
21	import org.eclipse.hyades.models.hierarchy.util.ISessionManager;	21	import org.eclipse.hyades.models.hierarchy.util.ISessionManager;
22	import org.eclipse.hyades.models.hierarchy.util.internal.SessionManagerWrapper;	22	import org.eclipse.hyades.models.hierarchy.util.internal.SessionManagerWrapper;
23	import org.eclipse.tptp.monitoring.log.provisional.cbeimport.IErrorHandler;	23	import org.eclipse.tptp.monitoring.log.provisional.cbeimport.IErrorHandler;

Lines 1-5 Link Here

(-)cbe.import/org/eclipse/tptp/monitoring/log/internal/core/GLAFilterHelper.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 69-75 Link Here
69	import org.eclipse.hyades.logging.events.cbe.EventPackage;	69	import org.eclipse.hyades.logging.events.cbe.EventPackage;
70	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;	70	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;
71	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	71	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
72	import org.eclipse.hyades.logging.parsers.internal.importer.GLAHelper;	72	import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
73	import org.eclipse.hyades.models.cbe.CBEPackage;	73	import org.eclipse.hyades.models.cbe.CBEPackage;
74	import org.eclipse.hyades.models.hierarchy.TRCAgent;	74	import org.eclipse.hyades.models.hierarchy.TRCAgent;
75	import org.eclipse.hyades.models.hierarchy.extensions.BinaryExpression;	75	import org.eclipse.hyades.models.hierarchy.extensions.BinaryExpression;

Lines 1-5 Link Here

(-)cbe.import/org/eclipse/tptp/monitoring/log/internal/core/LocalDownloadImportHandler.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 31-37 Link Here
31	import org.eclipse.core.runtime.Status;	31	import org.eclipse.core.runtime.Status;
32	import org.eclipse.hyades.execution.local.CommunicationDebug;	32	import org.eclipse.hyades.execution.local.CommunicationDebug;
33	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;	33	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;
34	import org.eclipse.hyades.logging.parsers.internal.importer.GLAHelper;	34	import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
35	import org.eclipse.hyades.ui.internal.util.StringUtil;	35	import org.eclipse.hyades.ui.internal.util.StringUtil;
36	import org.eclipse.tptp.monitoring.log.provisional.cbeimport.IImportHandler;	36	import org.eclipse.tptp.monitoring.log.provisional.cbeimport.IImportHandler;
37	import org.eclipse.tptp.monitoring.log.provisional.cbeimport.ILogFileElement;	37	import org.eclipse.tptp.monitoring.log.provisional.cbeimport.ILogFileElement;

Lines 1-5 Link Here

(-)cbe.import/org/eclipse/tptp/monitoring/log/internal/core/LocalImportHandler.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 25-31 Link Here
25	import org.eclipse.core.runtime.Status;	25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.hyades.loaders.util.LoadersUtils;	26	import org.eclipse.hyades.loaders.util.LoadersUtils;
27	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;	27	import org.eclipse.hyades.logging.parsers.LoggingParsersPlugin;
28	import org.eclipse.hyades.logging.parsers.internal.importer.LocalGLALogger;	28	import org.eclipse.hyades.logging.parsers.provisional.importer.LocalGLALogger;
29	import org.eclipse.hyades.models.hierarchy.util.MonitoredInputStream;	29	import org.eclipse.hyades.models.hierarchy.util.MonitoredInputStream;
30	import org.eclipse.hyades.models.util.ModelDebugger;	30	import org.eclipse.hyades.models.util.ModelDebugger;
31	import org.eclipse.osgi.util.NLS;	31	import org.eclipse.osgi.util.NLS;

Lines 1-5 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/wizards/LogSetManager.java (-1 / +1 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at




/**********************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * 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

import org.eclipse.hyades.logging.events.cbe.util.EventFormatter;
import org.eclipse.hyades.logging.events.cbe.util.EventHelpers;
import org.eclipse.hyades.logging.parsers.importer.ILogParser;
import org.eclipse.hyades.logging.parsers.provisional.importer.LocalLogImportLoader;

/**
 * 
 * @deprecated since TPTP 4.4 - this class was moved to org.eclipse.hyades.logging.parsers.provisional.importer
 * package in TPTP 4.3.
 *
 */

Lines 1-5 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/wizards/LocalGLALogger.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 20-26 Link Here
20		20
21	/**	21	/**
22	*	22	*
23	* @deprecated since TPTP 4.4 - this class was moved to org.eclipse.hyades.logging.parsers.internal.importer	23	* @deprecated since TPTP 4.4 - this class was moved to org.eclipse.hyades.logging.parsers.provisional.importer
24	* package in TPTP 4.3.	24	* package in TPTP 4.3.
25	*	25	*
26	*/	26	*/

Lines 54-60 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/wizards/ImportLogWizard.java (-1 / +1 lines)
54	import org.eclipse.hyades.loaders.util.LoadersUtils;	54	import org.eclipse.hyades.loaders.util.LoadersUtils;
55	import org.eclipse.hyades.logging.parsers.importer.ILogParser;	55	import org.eclipse.hyades.logging.parsers.importer.ILogParser;
56	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	56	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
57	import org.eclipse.hyades.logging.parsers.internal.importer.GLAHelper;	57	import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
58	import org.eclipse.hyades.models.hierarchy.CorrelationContainerProxy;	58	import org.eclipse.hyades.models.hierarchy.CorrelationContainerProxy;
59	import org.eclipse.hyades.models.hierarchy.TRCAgent;	59	import org.eclipse.hyades.models.hierarchy.TRCAgent;
60	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;	60	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;

Lines 1-5 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/util/ImportLogHelper.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 43-49 Link Here
43	import org.eclipse.hyades.logging.parsers.adapter.sensors.StaticParserSensor;	43	import org.eclipse.hyades.logging.parsers.adapter.sensors.StaticParserSensor;
44	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	44	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
45	import org.eclipse.hyades.logging.parsers.internal.adapter.outputters.CBEtoCSVOutputter;	45	import org.eclipse.hyades.logging.parsers.internal.adapter.outputters.CBEtoCSVOutputter;
46	import org.eclipse.hyades.logging.parsers.internal.importer.GLAHelper;	46	import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
47	import org.eclipse.hyades.models.hierarchy.TRCAgent;	47	import org.eclipse.hyades.models.hierarchy.TRCAgent;
48	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;	48	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;
49	import org.eclipse.hyades.models.hierarchy.util.IHyadesResourceExtension;	49	import org.eclipse.hyades.models.hierarchy.util.IHyadesResourceExtension;

Lines 1-5 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/util/GLAFilterHelper.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005, 2006 IBM Corporation and others.	2	* Copyright (c) 2005, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 67-73 Link Here
67	import org.eclipse.hyades.logging.adapter.model.internal.outputter.OutputterFactory;	67	import org.eclipse.hyades.logging.adapter.model.internal.outputter.OutputterFactory;
68	import org.eclipse.hyades.logging.events.cbe.EventPackage;	68	import org.eclipse.hyades.logging.events.cbe.EventPackage;
69	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;	69	import org.eclipse.hyades.logging.parsers.importer.LogParserConstants;
70	import org.eclipse.hyades.logging.parsers.internal.importer.GLAHelper;	70	import org.eclipse.hyades.logging.parsers.provisional.importer.GLAHelper;
71	import org.eclipse.hyades.models.cbe.CBEPackage;	71	import org.eclipse.hyades.models.cbe.CBEPackage;
72	import org.eclipse.hyades.models.hierarchy.TRCAgent;	72	import org.eclipse.hyades.models.hierarchy.TRCAgent;
73	import org.eclipse.hyades.models.hierarchy.extensions.BinaryExpression;	73	import org.eclipse.hyades.models.hierarchy.extensions.BinaryExpression;

Return to bug 208728

Removed Link Here

(-)src.import/org/eclipse/hyades/logging/parsers/internal/importer/GLALoggerFactory.java (-88 lines)
1	/**********************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: GLALoggerFactory.java,v 1.1 2005/06/28 19:33:31 dnsmith Exp $
8	*
9	* Contributors:
10	* IBM - Initial API and implementation
11	**********************************************************************/
12
13	package org.eclipse.hyades.logging.parsers.internal.importer;
14
15	import org.apache.commons.logging.Log;
16	import org.apache.commons.logging.LogConfigurationException;
17	import org.eclipse.hyades.logging.commons.LoggerFactory;
18
19	/**
20	* This class extends org.eclipse.hyades.logging.commons.LoggerFactory
21	* to instantiate the org.eclpise.hyades.logging.parsers.GLALogger class.
22	*
23	* @see org.apache.commons.logging.LogFactory
24	* @see org.eclipse.hyades.logging.commons.Logger
25	* @see org.eclipse.hyades.logging.commons.LoggerFactory
26	* @see org.eclipse.hyades.logging.parsers.internal.importer.GLALogger
27	*/
28	public class GLALoggerFactory extends LoggerFactory {
29
30	/**
31	* No-argument constructor.
32	*/
33	public GLALoggerFactory() {
34	super();
35	}
36
37	/**
38	* Returns an instance of a non-null named
39	* <code>org.eclipse.hyades.logging.parsers.GLALogger</code> based on the
40	* parameter name.
41	* <p>
42	* Passing a <code>null</code> logger name results in a <code>null</code>
43	* return value.
44	* <p>
45	* An instance of a named
46	* <code>org.eclipse.hyades.logging.parsers.GLALogger</code> is created if no
47	* named instance current exists or all instances have been released.
48	* <p>
49	* Once a named <code>org.eclipse.hyades.logging.parsers.GLALogger</code> is
50	* created, the instance is cached for future calls to retrieve the same
51	* named <code>org.eclipse.hyades.logging.parsers.GLALogger</code>.
52	* <p>
53	* The name of the <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
54	* uniquely identifies an instance of an
55	* <code>org.eclipse.hyades.logging.parsers.GLALogger</code>. All subsequent
56	* calls will return the same instance of the named
57	* <code>org.eclipse.hyades.logging.parsers.GLALogger</code>.
58	* <p>
59	*
60	* @param loggerName
61	* The non-null name of the returned
62	* <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
63	* instance.
64	* @return A named <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
65	* instance, otherwise <code>null</code> if the parameter logger
66	* name is <code>null</code>.
67	* @exception LogConfigurationException
68	* if the named
69	* <code>org.eclipse.hyades.logging.parsers.GLALogger</code>
70	* instance could not be created.
71	* @see org.apache.commons.logging.LogFactory#getInstance(java.lang.String)
72	*/
73	public Log getInstance(String loggerName) throws LogConfigurationException {
74
75	if (loggerName != null) {
76
77	if (loggers.containsKey(loggerName)) { return (((Log) (loggers.get(loggerName)))); }
78
79	GLALogger logger = new GLALogger(loggerName);
80
81	loggers.put(loggerName, logger);
82
83	return logger;
84	}
85
86	return null;
87	}
88	}

Removed Link Here

(-)src.import/org/eclipse/hyades/logging/parsers/internal/importer/LocalLogImportLoader.java (-179 lines)
1	/**********************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM - Initial API and implementation
10	*
11	* Change History:
12	**********************************************************************/
13	package org.eclipse.hyades.logging.parsers.internal.importer;
14
15	import java.util.Hashtable;
16
17	import org.apache.commons.logging.Log;
18	import org.eclipse.hyades.loaders.util.XMLLoader;
19	import org.eclipse.hyades.logging.parsers.LogParserException;
20	import org.eclipse.hyades.logging.parsers.importer.ILogParser;
21
22	/**
23	*
24	* This is a specialized logger to be used by GLA for local log imports. It is
25	* instantiated by clients and passed to GLA via ParserWrapper.parse(Log) method.
26	* Currently it is available internally only for use by the Log Import Wizard in
27	* org.eclipse.tptp.monitoring.logui
28	*
29	* @author Cindy Jin
30	*
31	*/
32	public class LocalLogImportLoader implements Log {
33
34
35	protected Hashtable parserParameters = null;
36	protected ILogParser parser = null;
37	protected XMLLoader xmlLoader = null;
38	protected Log logParser = null;
39	protected boolean traceXML = false;
40
41	/**
42	* Trace logging level value.
43	*/
44	public static final int TRACE_LEVEL = 0;
45
46	/**
47	* Debug logging level value.
48	*/
49	public static final int DEBUG_LEVEL = 1;
50
51	/**
52	* Information logging level value.
53	*/
54	public static final int INFO_LEVEL = 2;
55
56	/**
57	* Warning logging level value.
58	*/
59	public static final int WARN_LEVEL = 3;
60
61	/**
62	* Error logging level value.
63	*/
64	public static final int ERROR_LEVEL = 4;
65
66	/**
67	* Fatal logging level value.
68	*/
69	public static final int FATAL_LEVEL = 5;
70
71	/**
72	* The logger's current logging level value.
73	*/
74	protected int loggingLevel;
75	public LocalLogImportLoader()
76	{
77	parser = null;
78	parserParameters = null;
79	}
80
81	public LocalLogImportLoader(ILogParser parser, Hashtable parserParameters, boolean traceXML) {
82	this.parser = parser;
83	this.parserParameters = parserParameters;
84	this.traceXML = traceXML;
85	}
86
87	public void setXMLLoader(XMLLoader xmlLoader) {
88	parserParameters.put("xmlLoader", xmlLoader);
89	this.xmlLoader = xmlLoader;
90	}
91
92
93	public void startParsing() throws LogParserException {
94	parser.setUserInput(parserParameters);
95	parser.parse(this);
96	}
97	public void setParserLogger(Log logParser){
98	this.logParser = logParser;
99	parser.setParserLogger(logParser);
100	}
101
102	public Log getParserLogger(){
103	return logParser;
104	}
105
106	public XMLLoader getXMLLoader()
107	{
108	return xmlLoader;
109	}
110
111	public boolean isTraceEnabled() {
112	return (loggingLevel<=TRACE_LEVEL);
113	}
114
115	public boolean isDebugEnabled() {
116	return (loggingLevel<=DEBUG_LEVEL);
117	}
118
119
120	public boolean isInfoEnabled() {
121	return (loggingLevel<=INFO_LEVEL);
122	}
123
124	public boolean isWarnEnabled() {
125	return (loggingLevel<=WARN_LEVEL);
126	}
127
128	public boolean isErrorEnabled() {
129	return (loggingLevel<=ERROR_LEVEL);
130	}
131
132	public boolean isFatalEnabled() {
133	return (loggingLevel<=FATAL_LEVEL);
134	}
135
136
137	public void trace(Object record) {
138	}
139
140	public void trace(Object record, Throwable throwable) {
141	}
142
143	public void debug(Object record) {
144	}
145
146	public void debug(Object record, Throwable throwable) {
147	}
148
149	public void info(Object record) {
150	}
151
152	public void info(Object record, Throwable throwable) {
153	}
154
155
156	public void warn(Object record) {
157	}
158
159	public void warn(Object record, Throwable throwable) {
160	}
161
162	public void error(Object record) {
163	}
164
165	public void error(Object record, Throwable throwable) {
166	}
167
168
169	public void fatal(Object record) {
170
171	}
172
173
174	public void fatal(Object record, Throwable throwable) {
175
176	}
177
178
179	}

Lines 110-115 Link Here

(-)schema/logParser.exsd (-16 / +14 lines)
110	</documentation>	110	</documentation>
111	</annotation>	111	</annotation>
112	</attribute>	112	</attribute>
		113	<attribute name="override_id" type="string">
		114	<annotation>
		115	<documentation>
		116	ID of logParser extension that this extension will override. Note, only those attributes included in this extension will be overridden.
		117	</documentation>
		118	</annotation>
		119	</attribute>
		120	<attribute name="override_priority" type="string">
		121	<annotation>
		122	<documentation>
		123	Numeric priority value used to evaluate the priority of this override extension in relation to other override extensions. A value of -1 indicates that the extension that is specified in override_id should be disabled and not available for use as a log parser. Note, this attribute is required if override_id is specified. This attribute is ignored if override_id is not specified.
		124	</documentation>
		125	</annotation>
		126	</attribute>
113	</complexType>	127	</complexType>
114	</element>	128	</element>
115		129
Lines 546-568 Link Here
546	</documentation>	560	</documentation>
547	</annotation>	561	</annotation>
548		562
549	<annotation>
550	<appInfo>
551	<meta.section type="apiInfo"/>
552	</appInfo>
553	<documentation>
554
555	</documentation>
556	</annotation>
557		563
558	<annotation>
559	<appInfo>
560	<meta.section type="implementation"/>
561	</appInfo>
562	<documentation>
563
564	</documentation>
565	</annotation>
566		564
567	<annotation>	565	<annotation>
568	<appInfo>	566	<appInfo>

Lines 1-5 Link Here

(-)src/org/eclipse/hyades/logging/parsers/adapter/sensors/StaticParserSensor.java (-27 / +44 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005,2006 IBM Corporation and others.	2	* Copyright (c) 2005,2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 91-108 Link Here
91	}	91	}
92		92
93	/**	93	/**
94	* Update the configuration based on the configuration Element	94	* Read the sensor configuration from the configuration element
95	* @throws AdapterInvalidConfig if the configuration processing failed.	95	* @param parserParameters Hashtable to put the sensor parameters in
96	* @see org.eclipse.hyades.logging.adapter.IComponent#update()
97	*/	96	*/
98	public void update() throws AdapterInvalidConfig	97	protected void readConfiguration(Hashtable parserParameters) {
99	{	98	// maximumBlocking is set by the sensor configuration
100	// first get the basic configuration set
101	super.update();
102	// maximumBlocking is set by the sensor config
103	String directory = null;
104	String fileName = null;
105	String className = null;
106		99
107	String propertyName = null;	100	String propertyName = null;
108	String propertyValue = null;	101	String propertyValue = null;
Lines 114-125 Link Here
114		107
115	// Make a copy of the sensor properties to use as the parserParameters	108	// Make a copy of the sensor properties to use as the parserParameters
116	Hashtable sensorParameters = getProperties();	109	Hashtable sensorParameters = getProperties();
117	Hashtable parserParameters = new Hashtable();
118		110
119	// This sensor may be configured with a sub element of the config	111	// This sensor may be configured with a sub element of the config
120	// or the sensor may be configured with sensor properties only.	112	// or the sensor may be configured with sensor properties only.
121		113
122	boolean propertiesPresent = false;
123	// Get the sensor parameters from the sensor properties	114	// Get the sensor parameters from the sensor properties
124	if (sensorParameters != null && !sensorParameters.isEmpty()) {	115	if (sensorParameters != null && !sensorParameters.isEmpty()) {
125	// bugzilla 160528 - copy the sensor properties into the parserParamenters hash table because	116	// bugzilla 160528 - copy the sensor properties into the parserParamenters hash table because
Lines 131-138 Link Here
131		122
132	fileName = (String)parserParameters.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);	123	fileName = (String)parserParameters.get(AdapterXMLConstants.HyadesGAfileNameAttributeName);
133		124
134	className = (String)parserParameters.get(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName);	125	parserClassName = (String)parserParameters.get(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName);
135	propertiesPresent = true;	126
136	}	127	}
137	else if (element != null) {	128	else if (element != null) {
138	/**	129	/**
Lines 158-164 Link Here
158	fileName = file;	149	fileName = file;
159	}	150	}
160	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName))	151	if (sensorTypeInstance.hasAttribute(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName))
161	className = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName);	152	parserClassName = sensorTypeInstance.getAttribute(AdapterXMLConstants.HyadesGAstaticParserClassAttributeName);
162		153
163	// Get the parameters from the sensor type instance properties	154	// Get the parameters from the sensor type instance properties
164	sensorNodes = sensorNode.getChildNodes();	155	sensorNodes = sensorNode.getChildNodes();
Lines 184-198 Link Here
184	}	175	}
185	}	176	}
186	}	177	}
187		178	}
		179
		180	/**
		181	* Process the values read from the configuration and update the hash table of
		182	* parameters if necessary.
		183	* @param parserParameters Hashtable of sensor parameters
		184	* @throws AdapterInvalidConfig
		185	*/
		186	protected void processConfiguration(Hashtable parserParameters) throws AdapterInvalidConfig {
188	// We must have a directory and fileName	187	// We must have a directory and fileName
189	if (directory == null \|\| directory.length() == 0 \|\| fileName == null \|\| fileName.length() == 0 \|\| className == null \|\| className.length() == 0) {	188	if (directory == null \|\| directory.length() == 0 \|\| fileName == null \|\| fileName.length() == 0 \|\| parserClassName == null \|\| parserClassName.length() == 0) {
190	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_StaticParserSensor_Invalid_Config_File_ERROR_"));	189	throw new AdapterInvalidConfig(Messages.getString("HyadesGA_CBE_StaticParserSensor_Invalid_Config_File_ERROR_"));
191	}	190	}
192		191
193	setDirectory(directory);	192	setDirectory(directory);
194	setFileName(fileName);	193	setFileName(fileName);
195	setParserClassName(className);	194	setParserClassName(parserClassName);
196		195
197	// Construct the full input log file name	196	// Construct the full input log file name
198	if (getDirectory().endsWith(PATH_SEPARATOR)) {	197	if (getDirectory().endsWith(PATH_SEPARATOR)) {
Lines 265-278 Link Here
265		264
266	parserParameters.put(ParserConstants.CONTINUOUS_KEY, new Boolean(continuousContext));	265	parserParameters.put(ParserConstants.CONTINUOUS_KEY, new Boolean(continuousContext));
267		266
268	/* bugzilla 91489 - if the directory and file name values are not already in the hash	267	/* bugzilla 91489 - reset the directory and file name values in the hash
269	* table then add them so the parser class can use them instead of file_path to handle	268	* table so the parser class can use them instead of file_path to handle
270	* regular expression values better.	269	* regular expression values better. The directory and file name values
		270	* may have been changed before getting to this point so they should be
		271	* reset in the hash table.
271	*/	272	*/
272	if (!propertiesPresent) {	273
273	parserParameters.put(ParserConstants.DIRECTORY_KEY, directory);	274	parserParameters.put(ParserConstants.DIRECTORY_KEY, directory);
274	parserParameters.put(ParserConstants.FILE_NAME_KEY, fileName);	275	parserParameters.put(ParserConstants.FILE_NAME_KEY, fileName);
275	}
276		276
277	// Get the static parser class instance	277	// Get the static parser class instance
278	try {	278	try {
Lines 296-301 Link Here
296	}	296	}
297		297
298	/**	298	/**
		299	* Update the configuration based on the configuration Element
		300	* @throws AdapterInvalidConfig if the configuration processing failed.
		301	* @see org.eclipse.hyades.logging.adapter.IComponent#update()
		302	*/
		303	public void update() throws AdapterInvalidConfig
		304	{
		305	// first get the basic configuration set
		306	super.update();
		307
		308	Hashtable parserParameters = new Hashtable();
		309
		310	readConfiguration(parserParameters);
		311
		312	processConfiguration(parserParameters);
		313	}
		314
		315	/**
299	* simulates a getNext	316	* simulates a getNext
300	* @see org.eclipse.hyades.logging.adapter.ISensor#testGetNext()	317	* @see org.eclipse.hyades.logging.adapter.ISensor#testGetNext()
301	*/	318	*/

Added Link Here

(-)src.import/org/eclipse/hyades/logging/parsers/provisional/importer/LocalLogImportLoader.java (+179 lines)
1	/**********************************************************************
2	* Copyright (c) 2006,2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM - Initial API and implementation
10	*
11	* Change History:
12	**********************************************************************/
13	package org.eclipse.hyades.logging.parsers.provisional.importer;
14
15	import java.util.Hashtable;
16
17	import org.apache.commons.logging.Log;
18	import org.eclipse.hyades.loaders.util.XMLLoader;
19	import org.eclipse.hyades.logging.parsers.LogParserException;
20	import org.eclipse.hyades.logging.parsers.importer.ILogParser;
21
22	/**
23	*
24	* This is a specialized logger to be used by GLA for local log imports. It is
25	* instantiated by clients and passed to GLA via ParserWrapper.parse(Log) method.
26	* Currently it is available internally only for use by the Log Import Wizard in
27	* org.eclipse.tptp.monitoring.logui
28	*
29	* @author Cindy Jin
30	*
31	*/
32	public class LocalLogImportLoader implements Log {
33
34
35	protected Hashtable parserParameters = null;
36	protected ILogParser parser = null;
37	protected XMLLoader xmlLoader = null;
38	protected Log logParser = null;
39	protected boolean traceXML = false;
40
41	/**
42	* Trace logging level value.
43	*/
44	public static final int TRACE_LEVEL = 0;
45
46	/**
47	* Debug logging level value.
48	*/
49	public static final int DEBUG_LEVEL = 1;
50
51	/**
52	* Information logging level value.
53	*/
54	public static final int INFO_LEVEL = 2;
55
56	/**
57	* Warning logging level value.
58	*/
59	public static final int WARN_LEVEL = 3;
60
61	/**
62	* Error logging level value.
63	*/
64	public static final int ERROR_LEVEL = 4;
65
66	/**
67	* Fatal logging level value.
68	*/
69	public static final int FATAL_LEVEL = 5;
70
71	/**
72	* The logger's current logging level value.
73	*/
74	protected int loggingLevel;
75	public LocalLogImportLoader()
76	{
77	parser = null;
78	parserParameters = null;
79	}
80
81	public LocalLogImportLoader(ILogParser parser, Hashtable parserParameters, boolean traceXML) {
82	this.parser = parser;
83	this.parserParameters = parserParameters;
84	this.traceXML = traceXML;
85	}
86
87	public void setXMLLoader(XMLLoader xmlLoader) {
88	parserParameters.put("xmlLoader", xmlLoader);
89	this.xmlLoader = xmlLoader;
90	}
91
92
93	public void startParsing() throws LogParserException {
94	parser.setUserInput(parserParameters);
95	parser.parse(this);
96	}
97	public void setParserLogger(Log logParser){
98	this.logParser = logParser;
99	parser.setParserLogger(logParser);
100	}
101
102	public Log getParserLogger(){
103	return logParser;
104	}
105
106	public XMLLoader getXMLLoader()
107	{
108	return xmlLoader;
109	}
110
111	public boolean isTraceEnabled() {
112	return (loggingLevel<=TRACE_LEVEL);
113	}
114
115	public boolean isDebugEnabled() {
116	return (loggingLevel<=DEBUG_LEVEL);
117	}
118
119
120	public boolean isInfoEnabled() {
121	return (loggingLevel<=INFO_LEVEL);
122	}
123
124	public boolean isWarnEnabled() {
125	return (loggingLevel<=WARN_LEVEL);
126	}
127
128	public boolean isErrorEnabled() {
129	return (loggingLevel<=ERROR_LEVEL);
130	}
131
132	public boolean isFatalEnabled() {
133	return (loggingLevel<=FATAL_LEVEL);
134	}
135
136
137	public void trace(Object record) {
138	}
139
140	public void trace(Object record, Throwable throwable) {
141	}
142
143	public void debug(Object record) {
144	}
145
146	public void debug(Object record, Throwable throwable) {
147	}
148
149	public void info(Object record) {
150	}
151
152	public void info(Object record, Throwable throwable) {
153	}
154
155
156	public void warn(Object record) {
157	}
158
159	public void warn(Object record, Throwable throwable) {
160	}
161
162	public void error(Object record) {
163	}
164
165	public void error(Object record, Throwable throwable) {
166	}
167
168
169	public void fatal(Object record) {
170
171	}
172
173
174	public void fatal(Object record, Throwable throwable) {
175
176	}
177
178
179	}

Added Link Here

(-)src/org/eclipse/hyades/logging/adapter/provisional/util/ControllerFactory.java (+32 lines)
1	/**********************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: Controller.java,v 1.9 2007/03/22 05:29:24 dnsmith Exp $
8	*
9	* Contributors:
10	* IBM - Initial API and implementation
11	*
12	**********************************************************************/
13
14	package org.eclipse.hyades.logging.adapter.provisional.util;
15
16	/**
17	* Implementation of an IControllerFactory that generates Controller instances
18	*
19	* @author smith
20	*
21	*/
22	public class ControllerFactory implements IControllerFactory {
23
24	/* (non-Javadoc)
25	* @see org.eclipse.hyades.logging.adapter.provisional.util.IControllerFactory#getController()
26	*/
27	public IController getController() {
28	// TODO Auto-generated method stub
29	return new Controller();
30	}
31
32	}