/*******************************************************************************
 * Copyright (c) 2005 The Regents of the University of California.
 * This material was produced under U.S. Government contract W-7405-ENG-36
 * for Los Alamos National Laboratory, which is operated by the University
 * of California for the U.S. Department of Energy. The U.S. Government has
 * rights to use, reproduce, and distribute this software. NEITHER THE
 * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
 * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
 * to produce derivative works, such modified software should be clearly marked,
 * so as not to confuse it with the version available from LANL.
 *
 * Additionally, 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
 *
 * LA-CC 04-115
 *******************************************************************************/
package org.eclipse.ptp.launch.internal;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.IBinaryParser;
import org.eclipse.cdt.core.ICExtensionReference;
import org.eclipse.cdt.core.IBinaryParser.IBinaryObject;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IPersistableSourceLocator;
import org.eclipse.debug.core.model.LaunchConfigurationDelegate;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ptp.core.IModelManager;
import org.eclipse.ptp.core.IPTPLaunchConfigurationConstants;
import org.eclipse.ptp.core.PTPCorePlugin;
import org.eclipse.ptp.core.attributes.AttributeManager;
import org.eclipse.ptp.core.attributes.BooleanAttribute;
import org.eclipse.ptp.core.attributes.EnumeratedAttribute;
import org.eclipse.ptp.core.attributes.IAttribute;
import org.eclipse.ptp.core.attributes.StringAttribute;
import org.eclipse.ptp.core.elementcontrols.IResourceManagerControl;
import org.eclipse.ptp.core.elements.IPJob;
import org.eclipse.ptp.core.elements.IPQueue;
import org.eclipse.ptp.core.elements.IPUniverse;
import org.eclipse.ptp.core.elements.IResourceManager;
import org.eclipse.ptp.core.elements.attributes.JobAttributes;
import org.eclipse.ptp.core.elements.attributes.ResourceManagerAttributes;
import org.eclipse.ptp.core.elements.events.IChangedJobEvent;
import org.eclipse.ptp.core.elements.events.IChangedMachineEvent;
import org.eclipse.ptp.core.elements.events.IChangedQueueEvent;
import org.eclipse.ptp.core.elements.events.INewJobEvent;
import org.eclipse.ptp.core.elements.events.INewMachineEvent;
import org.eclipse.ptp.core.elements.events.INewQueueEvent;
import org.eclipse.ptp.core.elements.events.IRemoveJobEvent;
import org.eclipse.ptp.core.elements.events.IRemoveMachineEvent;
import org.eclipse.ptp.core.elements.events.IRemoveQueueEvent;
import org.eclipse.ptp.core.elements.events.IResourceManagerChangeEvent;
import org.eclipse.ptp.core.elements.events.IResourceManagerErrorEvent;
import org.eclipse.ptp.core.elements.events.IResourceManagerSubmitJobErrorEvent;
import org.eclipse.ptp.core.elements.listeners.IQueueChildListener;
import org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener;
import org.eclipse.ptp.core.elements.listeners.IResourceManagerListener;
import org.eclipse.ptp.core.events.IChangedResourceManagerEvent;
import org.eclipse.ptp.core.events.INewResourceManagerEvent;
import org.eclipse.ptp.core.events.IRemoveResourceManagerEvent;
import org.eclipse.ptp.core.listeners.IModelManagerChildListener;
import org.eclipse.ptp.debug.core.IPDebugConfiguration;
import org.eclipse.ptp.debug.core.IPDebugger;
import org.eclipse.ptp.debug.core.PTPDebugCorePlugin;
import org.eclipse.ptp.debug.core.launch.IPLaunch;
import org.eclipse.ptp.debug.core.launch.PLaunch;
import org.eclipse.ptp.debug.ui.PTPDebugUIPlugin;
import org.eclipse.ptp.launch.PTPLaunchPlugin;
import org.eclipse.ptp.launch.data.ISynchronizationRule;
import org.eclipse.ptp.launch.data.RuleFactory;
import org.eclipse.ptp.launch.messages.Messages;
import org.eclipse.ptp.launch.rulesengine.ILaunchProcessCallback;
import org.eclipse.ptp.launch.rulesengine.IRuleAction;
import org.eclipse.ptp.launch.rulesengine.RuleActionFactory;
import org.eclipse.ptp.launch.ui.extensions.AbstractRMLaunchConfigurationFactory;
import org.eclipse.ptp.launch.ui.extensions.IRMLaunchConfigurationDynamicTab;
import org.eclipse.ptp.remote.core.IRemoteConnection;
import org.eclipse.ptp.remote.core.IRemoteConnectionManager;
import org.eclipse.ptp.remote.core.IRemoteFileManager;
import org.eclipse.ptp.remote.core.IRemoteServices;
import org.eclipse.ptp.remote.core.PTPRemoteCorePlugin;
import org.eclipse.ptp.rm.remote.core.AbstractRemoteResourceManagerConfiguration;
import org.eclipse.ptp.rmsystem.IResourceManagerConfiguration;
import org.eclipse.ptp.utils.core.linux.ArgumentParser;

/**
 *
 */
public abstract class AbstractParallelLaunchConfigurationDelegate extends
		LaunchConfigurationDelegate implements ILaunchProcessCallback {
	private List<ISynchronizationRule> extraSynchronizationRules;
	public enum JobStatus {SUBMITTED, COMPLETED, ERROR}

	/**
	 * The JobSubmission class encapsulates all the information used in
	 * a job submission. Once the job is created *and starts running*,
	 * this information is used to complete the launch.
	 */
	private class JobSubmission {
		private ILaunchConfiguration configuration;
		private String mode;
		private String id;
		private String error = null;
		private IPLaunch launch;
		private AttributeManager attrMgr;
		private IPDebugger debugger;
		private JobStatus status = JobStatus.SUBMITTED;
		private final ReentrantLock subLock = new ReentrantLock();;
		private final Condition subCondition = subLock.newCondition();

		public JobSubmission(int count, ILaunchConfiguration configuration, String mode, IPLaunch launch,
				AttributeManager attrMgr, IPDebugger debugger) {
			this.configuration = configuration;
			this.mode = mode;
			this.launch = launch;
			this.attrMgr = attrMgr;
			this.debugger = debugger;
			this.id = "JOB_" + Long.toString(System.currentTimeMillis()) + Integer.toString(count); //$NON-NLS-1$
		}

		/**
		 * Wait for the job state to change
		 *
		 * @return the state
		 */
		public JobStatus waitFor(IProgressMonitor monitor) {
			subLock.lock();
			try {
				while (!monitor.isCanceled() && status != JobStatus.SUBMITTED) {
					try {
						subCondition.await(100, TimeUnit.MILLISECONDS);
					} catch (InterruptedException e) {
						// Expect to be interrupted if monitor is canceled
					}
				}

				return status;
			} finally {
				subLock.unlock();
			}
		}

		/**
		 * @return the attrMgr
		 */
		public AttributeManager getAttrMgr() {
			return attrMgr;
		}

		/**
		 * @return the configuration
		 */
		public ILaunchConfiguration getConfiguration() {
			return configuration;
		}

		/**
		 * @return the debugger
		 */
		public IPDebugger getDebugger() {
			return debugger;
		}

		/**
		 * @return the error
		 */
		public String getError() {
			return error;
		}

		/**
		 * @return the job submission id
		 */
		public String getId() {
			return id;
		}

		/**
		 * @return the launch
		 */
		public IPLaunch getLaunch() {
			return launch;
		}

		/**
		 * @return the mode
		 */
		public String getMode() {
			return mode;
		}

		/**
		 * set the error
		 */
		public void setError(String error) {
			this.error = error;
			setStatus(JobStatus.ERROR);
		}

		/**
		 * set the current status
		 */
		public void setStatus(JobStatus status) {
			subLock.lock();
			try {
				this.status = status;
				subCondition.signalAll();
			} finally {
				subLock.unlock();
			}
		}
	}

	private final class MMChildListener implements IModelManagerChildListener {
		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.listeners.IModelManagerChildListener#handleEvent(org.eclipse.ptp.core.events.IChangedResourceManagerEvent)
		 */
		public void handleEvent(IChangedResourceManagerEvent e) {
			// Don't need to do anything
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.listeners.IModelManagerChildListener#handleEvent(org.eclipse.ptp.core.events.INewResourceManagerEvent)
		 */
		public void handleEvent(INewResourceManagerEvent e) {
			/*
			 * Add resource manager child listener so we get notified when new
			 * machines are added to the model.
			 */
			final IResourceManager rm = e.getResourceManager();
	        rm.addChildListener(resourceManagerChildListener);
	        rm.addElementListener(resourceManagerListener);
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.listeners.IModelManagerChildListener#handleEvent(org.eclipse.ptp.core.events.IRemoveResourceManagerEvent)
		 */
		public void handleEvent(IRemoveResourceManagerEvent e) {
			/*
			 * Removed resource manager child listener when resource manager is removed.
			 */
			final IResourceManager rm = e.getResourceManager();
	        rm.removeChildListener(resourceManagerChildListener);
	        rm.removeElementListener(resourceManagerListener);
		}
	}

	private final class QueueChildListener implements IQueueChildListener {
		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IQueueChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IChangedJobEvent)
		 */
		public void handleEvent(IChangedJobEvent e) {
			for (IPJob job : e.getJobs()) {
				/*
				 * If the job state has changed to running, find the JobSubmission that
				 * corresponds to this job and perform remainder of job launch actions
				 */
				StringAttribute subIdAttr = job.getAttribute(JobAttributes.getSubIdAttributeDefinition());
				if (subIdAttr != null) {
					IAttribute<?,?,?> stateAttr = job.getAttribute(JobAttributes.getStateAttributeDefinition());
					if (stateAttr != null) {
						JobAttributes.State state = (JobAttributes.State)((EnumeratedAttribute<?>)stateAttr).getValue();
						if (state == JobAttributes.State.RUNNING) {
							JobSubmission jobSub = jobSubmissions.remove(subIdAttr.getValue());
							if (jobSub != null) {
								jobSub.setStatus(JobStatus.COMPLETED);
								doCompleteJobLaunch(jobSub.getConfiguration(), jobSub.getMode(), jobSub.getLaunch(), jobSub.getAttrMgr(), jobSub.getDebugger(), job);
							}
						} else if(state == JobAttributes.State.TERMINATED || state == JobAttributes.State.ERROR) {
							JobSubmission jobSub = jobInfos.remove(subIdAttr.getValue());
							if(jobSub != null) {
								if (state == JobAttributes.State.TERMINATED) {
									ILaunchConfiguration lconf = jobSub.getConfiguration();
									// If needed, copy data back.
									try {
										// Get the list of paths to be copied back.
										doPosLaunchSynchronization(lconf);
									} catch (CoreException e1) {
										PTPLaunchPlugin.log(e1);
									}
								}
								doCleanuoLaunch(jobSub.getConfiguration(), jobSub.getMode(), jobSub.getLaunch(), jobSub.getAttrMgr(), jobSub.getDebugger(), job);
							}
						}
					}
				}
			}
		}


		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IQueueChildListener#handleEvent(org.eclipse.ptp.core.elements.events.INewJobEvent)
		 */
		public void handleEvent(INewJobEvent e) {
			for (IPJob job : e.getJobs()) {
				/*
				 * If the new job is one that we launched, check to see if it's in our list
				 * of job submissions. If not, assume that we have reconnected to a session
				 * so we need to re-create the launch configuration that was used launch it.
				 * If it's a debug job, and it has not yet started running, then
				 * start a debug session. It's possible the job will never run, so we
				 * need to clean up any debug sessions before exiting Eclipse.
				 */
				StringAttribute subAttr = job.getAttribute(JobAttributes.getSubIdAttributeDefinition());
				if (subAttr != null) {
					IAttribute<?,?,?> launchAttr = job.getAttribute(JobAttributes.getLaunchedByPTPFlagAttributeDefinition());
					if (launchAttr != null && ((BooleanAttribute)launchAttr).getValue()) {
						JobSubmission jobSub = jobSubmissions.get(subAttr.getValue());
						if (jobSub == null) {
							// recreate launch configuration
							// jobSub = ....;
							// jobSubmissions.put(job, jobSub);
						}
						IAttribute<?,?,?> debugAttr = job.getAttribute(JobAttributes.getDebugFlagAttributeDefinition());
						if (debugAttr != null && ((BooleanAttribute)debugAttr).getValue()) {
						}
					}
				}
			}
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IQueueChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IRemoveJobEvent)
		 */
		public void handleEvent(IRemoveJobEvent e) {
		}
	}

	private final class RMChildListener implements IResourceManagerChildListener {
		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerMachineListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerChangedMachineEvent)
		 */
		public void handleEvent(IChangedMachineEvent e) {
			// Don't need to do anything
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerChangedQueueEvent)
		 */
		public void handleEvent(IChangedQueueEvent e) {
			// Can safely ignore
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerMachineListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerNewMachineEvent)
		 */
		public void handleEvent(INewMachineEvent e) {
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.INewQueueEvent)
		 */
		public void handleEvent(INewQueueEvent e) {
			for (IPQueue queue : e.getQueues()) {
				queue.addChildListener(queueChildListener);
			}
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerMachineListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerRemoveMachineEvent)
		 */
		public void handleEvent(IRemoveMachineEvent e) {
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerChildListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerRemoveQueueEvent)
		 */
		public void handleEvent(IRemoveQueueEvent e) {
			for (IPQueue queue : e.getQueues()) {
				queue.removeChildListener(queueChildListener);
			}
		}
	}

	private final class RMListener implements IResourceManagerListener {
		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerChangeEvent)
		 */
		public void handleEvent(IResourceManagerChangeEvent e) {
			// Ignore
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerErrorEvent)
		 */
		public void handleEvent(IResourceManagerErrorEvent e) {
			// TODO Auto-generated method stub
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ptp.core.elements.listeners.IResourceManagerListener#handleEvent(org.eclipse.ptp.core.elements.events.IResourceManagerSubmitJobErrorEvent)
		 */
		public void handleEvent(IResourceManagerSubmitJobErrorEvent e) {
			JobSubmission jobSub = jobSubmissions.remove(e.getJobSubmissionId());
			jobSub.setError(e.getMessage());
		}
	}

    /**
	 * Get the program arguments specified in the Arguments tab
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getArguments(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_ARGUMENTS, (String)null);
	}

	/**
	 * Get the debugger executable path
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getDebuggerExePath(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_DEBUGGER_EXECUTABLE_PATH, (String)null);
	}

	/**
	 * Get the ID of the debugger for this launch
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getDebuggerID(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_DEBUGGER_ID, (String)null);
	}

	/**
     * Get the debugger "stop in main" flag
     *
	 * @param configuration
	 * @return "stop in main" flag
	 * @throws CoreException
	 */
	protected static boolean getDebuggerStopInMainFlag(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_STOP_IN_MAIN, false);
	}

	/**
	 * Get the working directory for this debug session
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getDebuggerWorkDirectory(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_DEBUGGER_WORKING_DIR, (String)null);
	}

	/**
     * Get the absolute path of the executable to launch. If the executable is on a remote machine,
     * this is the path to the executable on that machine.
     *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getExecutablePath(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_EXECUTABLE_PATH, (String)null);
	}

    /**
	 * Get the name of the application to launch
	 *
	 * @deprecated
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	@Deprecated
	protected static String getProgramName(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_APPLICATION_NAME, (String)null);
	}

	/**
	 * Get the name of the project
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getProjectName(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String)null);
	}

	/**
	 * Get the name of the queue for the launch
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getQueueName(ILaunchConfiguration configuration) throws CoreException {
		return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_QUEUE_NAME, (String)null);
	}

	/**
	 * Get the resource manager to use for the launch
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getResourceManagerUniqueName(ILaunchConfiguration configuration) throws CoreException {
		return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_RESOURCE_MANAGER_UNIQUENAME, (String)null);
	}

	/**
     * Get the working directory for the application launch
     *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected static String getWorkDirectory(ILaunchConfiguration configuration) throws CoreException {
	    return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_WORK_DIRECTORY, (String)null);
	}

	/**
	 * Get if the executable shall be copied to remote target before launch.
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	public boolean getCopyExecutable(ILaunchConfiguration configuration)
			throws CoreException {
		return configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_COPY_EXECUTABLE, false);
	}

	private int jobCount = 0;

	/*
	 * Model listeners
	 */
	private final IModelManagerChildListener modelManagerChildListener = new MMChildListener();
	private final IResourceManagerChildListener resourceManagerChildListener = new RMChildListener();
	private final IResourceManagerListener resourceManagerListener = new RMListener();
	private final IQueueChildListener queueChildListener = new QueueChildListener();
	/*
	 * HashMap used to keep track of job submissions
	 */
	protected Map<String, JobSubmission> jobSubmissions = Collections.synchronizedMap(new HashMap<String, JobSubmission>());
	/*
	 * Temporary workaround. Leave a copy of jobSubmissions to get job information even after the submission.
	 */
	protected Map<String, JobSubmission> jobInfos = Collections.synchronizedMap(new HashMap<String, JobSubmission>());

	public AbstractParallelLaunchConfigurationDelegate() {
		IModelManager mm = PTPCorePlugin.getDefault().getModelManager();
		synchronized (mm) {
		    for (IResourceManager rm : mm.getUniverse().getResourceManagers()) {
		    	for (IPQueue queue : rm.getQueues()) {
		    		queue.addChildListener(queueChildListener);
		    	}
		        rm.addChildListener(resourceManagerChildListener);
		        rm.addElementListener(resourceManagerListener);
		    }
		    mm.addListener(modelManagerChildListener);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.LaunchConfigurationDelegate#getLaunch(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	@Override
	public ILaunch getLaunch(ILaunchConfiguration configuration, String mode) throws CoreException {
		return new PLaunch(configuration, mode, null);
	}

	/**
	 * Get the attributes from the resource manager specific launch page.
	 *
	 * @param configuration
	 * @param mode
	 * @return IAttribute[]
	 * @throws CoreException
	 */
	private IAttribute<?,?,?>[] getResourceAttributes(ILaunchConfiguration configuration, String mode)
		throws CoreException {

		IResourceManager rm = getResourceManager(configuration);

		final AbstractRMLaunchConfigurationFactory rmFactory =
			PTPLaunchPlugin.getDefault().getRMLaunchConfigurationFactory(rm);
		if (rmFactory == null) {
			return new IAttribute[0];
		}
		IRMLaunchConfigurationDynamicTab rmDynamicTab = rmFactory.create(rm);
		return rmDynamicTab.getAttributes(rm, null, configuration, mode);
	}

	/**
	 * Abort the job launch if anything goes wrong.
	 *
	 * @param message
	 * @param exception
	 * @param code
	 * @throws CoreException
	 */
	protected void abort(String message, Throwable exception, int code) throws CoreException {
	    throw new CoreException(new Status(IStatus.ERROR, PTPLaunchPlugin.getUniqueIdentifier(), code, message, exception));
	}

	/**
	 * This method is called when the job state changes to RUNNING. This allows the launcher to
	 * complete the job launch.
	 *
	 * @param configuration
	 * @param mode
	 * @param launch
	 * @param mgr
	 * @param debugger
	 * @param job
	 */
	protected abstract void doCompleteJobLaunch(ILaunchConfiguration configuration, String mode, IPLaunch launch,
			AttributeManager mgr, IPDebugger debugger, IPJob job);

	protected abstract void doCleanuoLaunch(ILaunchConfiguration configuration,
			String mode, IPLaunch launch, AttributeManager attrMgr,
			IPDebugger debugger, IPJob job);

//	protected void doCleanupJobLaunch(ILaunchConfiguration configuration, String mode,
//			IPLaunch launch, AttributeManager attrMgr, IPDebugger debugger,
//			IPJob job) {
//		if (debugger != null) {
//			debugger.cleanup(configuration, attrMgr, launch);
//		}
//	}

	/**
	 * Get all the attributes specified in the launch configuration.
	 *
	 * @param configuration
	 * @param mode
	 * @return AttributeManager
	 * @throws CoreException
	 */
	protected AttributeManager getAttributeManager(ILaunchConfiguration configuration, String mode) throws CoreException {
		IResourceManager rm = getResourceManager(configuration);
		if (rm == null) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_No_ResourceManager, null, 0);
		}

		AttributeManager attrMgr = new AttributeManager();

		/*
		 * Collect attributes from Resources tab
		 */
		attrMgr.addAttributes(getResourceAttributes(configuration, mode));

		/*
		 * Make sure there is a queue, even if the resources tab doesn't require
		 * one to be specified.
		 */
		if (attrMgr.getAttribute(JobAttributes.getQueueIdAttributeDefinition()) == null) {
			IPQueue queue = getQueueDefault(rm);
			attrMgr.addAttribute(JobAttributes.getQueueIdAttributeDefinition().create(queue.getID()));
		}

		/*
		 * Collect attributes from Application tab
		 */
		IPath programPath = verifyExecutablePath(configuration);
		attrMgr.addAttribute(JobAttributes.getExecutableNameAttributeDefinition().create(programPath.lastSegment()));

		String path = programPath.removeLastSegments(1).toString();
		if (path != null) {
			attrMgr.addAttribute(JobAttributes.getExecutablePathAttributeDefinition().create(path));
		}

		/*
		 * Collect attributes from Debugger tab
		 */
		verifyDebuggerPath(configuration);
		Boolean stopInMainFlag = getDebuggerStopInMainFlag(configuration);
		attrMgr.addAttribute(JobAttributes.getDebuggerStopInMainFlagAttributeDefinition().create(stopInMainFlag));

		/*
		 * Collect attributes from Arguments tab
		 */
		String wd = verifyWorkDirectory(configuration);
		if (wd != null) {
			attrMgr.addAttribute(JobAttributes.getWorkingDirectoryAttributeDefinition().create(wd));
		}

		String[] argArr = getProgramArguments(configuration);
		if (argArr != null) {
			attrMgr.addAttribute(JobAttributes.getProgramArgumentsAttributeDefinition().create(argArr));
		}

		/*
		 * Collect attributes from Environment tab
		 */
		String[] envArr = getEnvironmentToAppend(configuration);
		if (envArr != null) {
			attrMgr.addAttribute(JobAttributes.getEnvironmentAttributeDefinition().create(envArr));
		}

		/*
		 * PTP launched this job
		 */
		attrMgr.addAttribute(JobAttributes.getLaunchedByPTPFlagAttributeDefinition().create(true));

		return attrMgr;
	}

	/**
	 * Get the debugger configuration
	 *
	 * @param configuration launch configuration
	 * @return debugger configuration
	 * @throws CoreException
	 */
	protected IPDebugConfiguration getDebugConfig(ILaunchConfiguration config) throws CoreException {
		IPDebugConfiguration dbgCfg = null;
		try {
			dbgCfg = PTPDebugCorePlugin.getDefault().getDebugConfiguration(getDebuggerID(config));
		} catch (CoreException e) {
			System.out.println("ParallelLaunchConfigurationDelegate.getDebugConfig() Error"); //$NON-NLS-1$
			throw e;
		}
		return dbgCfg;
	}

	/**
	 * Convert application arguments to an array of strings.
	 *
	 * @param configuration launch configuration
	 * @return array of strings containing the program arguments
	 * @throws CoreException
	 */
	protected String[] getProgramArguments(ILaunchConfiguration configuration) throws CoreException {
		String temp = getArguments(configuration);
		if (temp != null && temp.length() > 0) {
			// Replaced PTPs ArgumentParser with better ArgumentParser contributed with RemoteTools.
//			ArgumentParser ap = new ArgumentParser(temp);
//			List<String> args = ap.getArguments();
			ArgumentParser ap = new ArgumentParser(temp);
			List<String> args = ap.getTokenList();
			if (args != null) {
				return args.toArray(new String[args.size()]);
			}
		}
		return new String[0];
	}

	/**
	 * Get the path of the program to launch. No longer used since the program may not be
	 * on the local machine.
	 *
	 * @deprecated
	 *
	 * @param configuration launch configuration
	 * @return IPath corresponding to program executable
	 * @throws CoreException
	 */
	@Deprecated
	protected IPath getProgramFile(ILaunchConfiguration configuration) throws CoreException {
		IProject project = verifyProject(configuration);
		String fileName = getProgramName(configuration);
		if (fileName == null)
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Application_file_not_specified, null, IStatus.INFO);

		IPath programPath = new Path(fileName);
		if (!programPath.isAbsolute()) {
			programPath = project.getFile(programPath).getLocation();
		}
		if (!programPath.toFile().exists()) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Application_file_does_not_exist,
					new FileNotFoundException(
							NLS.bind(Messages.AbstractParallelLaunchConfigurationDelegate_Path_not_found, new Object[] {programPath.toString()})),
							IPTPLaunchConfigurationConstants.ERR_PROGRAM_NOT_EXIST);
		}
		/* --old
		IFile programPath = project.getFile(fileName);
		if (programPath == null || !programPath.exists() || !programPath.getLocation().toFile().exists())
			abort(LaunchMessages.getResourceString("AbstractParallelLaunchConfigurationDelegate.Application_file_does_not_exist"), new FileNotFoundException(LaunchMessages.getFormattedResourceString("AbstractParallelLaunchConfigurationDelegate.Application_path_not_found", programPath.getLocation().toString())), IStatus.INFO);
		 */
		return programPath;
	}

	/**
	 * Get the IProject object from the project name.
	 *
     * @param project name of the project
     * @return IProject resource
     */
    protected IProject getProject(String project) {
        return getWorkspaceRoot().getProject(project);
    }

	/**
	 * Get the default queue for the given resource manager
	 *
	 * @param rm resource manager
	 * @return default queue
	 */
	protected IPQueue getQueueDefault(IResourceManager rm) {
		final IPQueue[] queues = rm.getQueues();
		if (queues.length == 0) {
			return null;
		}
		return queues[0];
	}

	/**
	 * Find the resource manager that corresponds to the unique name specified in the configuration
	 *
	 * @param configuration launch configuration
	 * @return resource manager
	 * @throws CoreException
	 */
	protected IResourceManager getResourceManager(ILaunchConfiguration configuration) throws CoreException {
		IPUniverse universe = PTPCorePlugin.getDefault().getUniverse();
		IResourceManager[] rms = universe.getResourceManagers();
		String rmUniqueName = getResourceManagerUniqueName(configuration);
		for (IResourceManager rm : rms) {
			if (rm.getState() == ResourceManagerAttributes.State.STARTED &&
					rm.getUniqueName().equals(rmUniqueName)) {
				return rm;
			}
		}
		return null;
	}

	/**
	 * Get the workspace root.
	 *
     * @return workspace root
     */
    protected IWorkspaceRoot getWorkspaceRoot() {
    	return ResourcesPlugin.getWorkspace().getRoot();
    }

	/**
	 * Create a source locator from the ID specified in the configuration, or create
	 * a default one if it hasn't been specified.
	 *
	 * @param launch
	 * @param configuration
	 * @throws CoreException
	 */
	protected void setDefaultSourceLocator(ILaunch launch, ILaunchConfiguration configuration) throws CoreException {
		//  set default source locator if none specified
		if (launch.getSourceLocator() == null) {
			IPersistableSourceLocator sourceLocator;
			String id = configuration.getAttribute(ILaunchConfiguration.ATTR_SOURCE_LOCATOR_ID, (String)null);
			if (id == null) {
				sourceLocator = PTPDebugUIPlugin.createDefaultSourceLocator();
				sourceLocator.initializeDefaults(configuration);
			} else {
				sourceLocator = DebugPlugin.getDefault().getLaunchManager().newSourceLocator(id);
				String memento = configuration.getAttribute(ILaunchConfiguration.ATTR_SOURCE_LOCATOR_MEMENTO, (String)null);
				if (memento == null) {
					sourceLocator.initializeDefaults(configuration);
				} else {
					sourceLocator.initializeFromMemento(memento);
				}
			}
			launch.setSourceLocator(sourceLocator);
		}
	}

	/**
	 * Set the source locator for this application
	 *
	 * @param launch
	 * @param config
	 * @throws CoreException
	 */
	protected void setSourceLocator(ILaunch launch, ILaunchConfiguration config) throws CoreException {
		setDefaultSourceLocator(launch, config);
	}

	/**
	 * Submit a job to the resource manager. Keeps track of the submission so we know when the
	 * job actually starts running. When this happens, the abstract method doCompleteJobLaunch()
	 * is invoked.
	 *
	 * @param configuration
	 * @param mode
	 * @param launch
	 * @param attrMgr
	 * @param debugger
	 * @param monitor
	 * @throws CoreException
	 */
	protected void submitJob(ILaunchConfiguration configuration, String mode, IPLaunch launch,
		AttributeManager attrMgr, IPDebugger debugger, IProgressMonitor monitor) throws CoreException {

		final IResourceManager rm = getResourceManager(configuration);
		if (rm == null) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_No_ResourceManager, null, 0);
		}

		JobSubmission jobSub = new JobSubmission(jobCount++, configuration, mode, launch, attrMgr, debugger);
		jobSubmissions.put(jobSub.getId(), jobSub);
		jobInfos.put(jobSub.getId(), jobSub);

		rm.submitJob(jobSub.getId(), configuration, attrMgr, monitor);

		JobStatus status = jobSub.waitFor(monitor);

		if (status == JobStatus.ERROR) {
			abort(jobSub.getError(), null, IStatus.ERROR);
		}
	}

	/**
	 * @param project
	 * @param exePath
	 * @return
	 * @throws CoreException
	 * @deprecated
	 */
	@Deprecated
	protected IBinaryObject verifyBinary(IProject project, IPath exePath) throws CoreException {
		ICExtensionReference[] parserRef = CCorePlugin.getDefault().getBinaryParserExtensions(project);
		for (int i = 0; i < parserRef.length; i++) {
			try {
				IBinaryParser parser = (IBinaryParser) parserRef[i].createExtension();
				IBinaryObject exe = (IBinaryObject) parser.getBinary(exePath);
				if (exe != null) {
					return exe;
				}
			} catch (ClassCastException e) {
			} catch (IOException e) {
			}
		}
		IBinaryParser parser = CCorePlugin.getDefault().getDefaultBinaryParser();
		try {
			return (IBinaryObject) parser.getBinary(exePath);
		} catch (ClassCastException e) {
		} catch (IOException e) {
		}
		Throwable exception = new FileNotFoundException(Messages.AbstractParallelLaunchConfigurationDelegate_Program_is_not_a_recongnized_executable);
		int code = IPTPLaunchConfigurationConstants.ERR_PROGRAM_NOT_BINARY;
		MultiStatus status = new MultiStatus(PTPCorePlugin.getUniqueIdentifier(), code, Messages.AbstractParallelLaunchConfigurationDelegate_Program_is_not_a_recongnized_executable, exception);
		status.add(new Status(IStatus.ERROR, PTPCorePlugin.getUniqueIdentifier(), code, exception == null ? "" : exception.getLocalizedMessage(), exception)); //$NON-NLS-1$
		throw new CoreException(status);
	}

	/**
	 * @param path
	 * @throws CoreException
	 */
	protected void verifyDebuggerPath(ILaunchConfiguration configuration) throws CoreException {
		String dbgPath = getDebuggerExePath(configuration);
		try {
			verifyResource(dbgPath, configuration);
		} catch (CoreException e) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Debugger_path_not_found,
					new FileNotFoundException(e.getLocalizedMessage()), IStatus.INFO);
		}
	}

	/**
	 * Verify the validity of executable path.
	 * If the executable is to be copied, then no additional verification is required.
	 * Otherwise, the path must point to an existing file.
	 * @param configuration
	 * @return
	 */
	protected IPath verifyExecutablePath(ILaunchConfiguration configuration)  throws CoreException {
		if (getCopyExecutable(configuration)) {
			return new Path(getExecutablePath(configuration));
		} else {
			String exePath = getExecutablePath(configuration);
			try {
				return verifyResource(exePath, configuration);
			} catch (CoreException e) {
				abort(Messages.AbstractParallelLaunchConfigurationDelegate_Application_file_does_not_exist,
						new FileNotFoundException(e.getLocalizedMessage()),	IStatus.INFO);
				return null;
			}
		}
	}

	/**
	 * @param path
	 * @return
	 * @deprecated
	 */
	@Deprecated
	protected boolean verifyPath(String path) {
		IPath programPath = new Path(path);
		if (programPath == null || programPath.isEmpty() || !programPath.toFile().exists()) {
			return false;
		}
		return true;
	}

	/**
	 * Verify that the project exists prior to the launch.
	 *
     * @param configuration
     * @return
     * @throws CoreException
     */
    protected IProject verifyProject(ILaunchConfiguration configuration) throws CoreException {
        String proName = getProjectName(configuration);
        if (proName == null) {
   			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Project_not_specified, null, IStatus.INFO);
        }

        IProject project = getProject(proName);
        if (project == null || !project.exists() || !project.isOpen()) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Project_does_not_exist_or_is_not_a_project, null, IStatus.INFO);
        }

        return project;
    }

	/**
	 * @param path
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected IPath verifyResource(String path, ILaunchConfiguration configuration) throws CoreException {
		IResourceManagerControl rm = (IResourceManagerControl)getResourceManager(configuration);
		if (rm == null) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_No_ResourceManager, null, IStatus.ERROR);
		}
		
		IResourceManagerConfiguration conf = rm.getConfiguration();
		if (!(conf instanceof AbstractRemoteResourceManagerConfiguration)) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Unsupported_resource_manager_type, null, IStatus.ERROR);
		}
		
		AbstractRemoteResourceManagerConfiguration remConf = (AbstractRemoteResourceManagerConfiguration)conf;
		IRemoteServices remoteServices = PTPRemoteCorePlugin.getDefault().getRemoteServices(remConf.getRemoteServicesId());
		if (remoteServices == null) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Unknown_remote_services, null, IStatus.ERROR);
		}
		IRemoteConnectionManager connMgr = remoteServices.getConnectionManager();
		IRemoteConnection conn = connMgr.getConnection(remConf.getConnectionName());
		IRemoteFileManager fileManager = remoteServices.getFileManager(conn);
		IPath resPath = new Path(path);
		try {
			IFileStore res = fileManager.getResource(resPath, new NullProgressMonitor());
			if (!res.fetchInfo().exists()) {
				abort(NLS.bind(Messages.AbstractParallelLaunchConfigurationDelegate_Path_not_found, new Object[] {path}), null, IStatus.INFO);
			}
		} catch (IOException e) {
			abort(Messages.AbstractParallelLaunchConfigurationDelegate_Error_fetching_resource, e.getCause(), IStatus.ERROR);
		}
		return resPath;
	}

	/**
	 * Check if the copy local file is enabled. If it is, copy the executable file from
	 * the local host to the remote host.
	 *
	 * @param configuration
	 * @throws CoreException
	 */
	protected void copyExecutable(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
		boolean copyExecutable =
			getCopyExecutable(configuration);

		if(copyExecutable) {
			// Get remote and local paths
			String remotePath = getExecutablePath(configuration);
			String localPath = configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_LOCAL_EXECUTABLE_PATH,
					(String)null);

			// Check if local path is valid
			if(localPath == null) {
				// Throws exception
			}

			// Copy data
			copyFileToRemoteHost(localPath, remotePath, configuration, monitor);
		}
	}

	/**
	 * Copy a data from a path (can be a file or directory) from the remote host to
	 * the local host.
	 *
	 * @param remotePath
	 * @param localPath
	 * @param configuration
	 * @throws CoreException
	 */
	protected void copyFileFromRemoteHost(String remotePath, String localPath, ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {

		/*IResourceManagerControl rm = (IResourceManagerControl)getResourceManager(configuration);
		if (rm != null) {
			IResourceManagerConfiguration conf = rm.getConfiguration();
			if (conf instanceof AbstractRemoteResourceManagerConfiguration) {
				AbstractRemoteResourceManagerConfiguration remConf = (AbstractRemoteResourceManagerConfiguration)conf;

				IRemoteServices localServices = PTPRemoteCorePlugin.getDefault().getRemoteServices("org.eclipse.ptp.remote.core.LocalServices");
				IRemoteServices remoteServices = PTPRemoteCorePlugin.getDefault().getRemoteServices(remConf.getRemoteServicesId());
				if (remoteServices != null && localServices != null) {
					IRemoteConnectionManager lconnMgr = localServices.getConnectionManager();
					IRemoteConnection lconn = lconnMgr.getConnection(null); // Since it's a local service, doesn't matter which parameter is passed*/
					IRemoteFileManager localFileManager = getLocalFileManager(configuration);//localServices.getFileManager(lconn);

					/*IRemoteConnectionManager rconnMgr = remoteServices.getConnectionManager();
					IRemoteConnection rconn = rconnMgr.getConnection(remConf.getConnectionName());*/
					IRemoteFileManager remoteFileManager = getRemoteFileManager(configuration);//remoteServices.getFileManager(rconn);

					try {
						IFileStore rres = remoteFileManager.getResource(new Path(remotePath), monitor);

						if(!rres.fetchInfo().exists()) {
							// Local file not found!
							throw new CoreException(new Status(IStatus.ERROR, PTPLaunchPlugin.PLUGIN_ID, 
									Messages.AbstractParallelLaunchConfigurationDelegate_Remote_resource_does_not_exist));
						}
						IFileStore lres = localFileManager.getResource(new Path(localPath), new NullProgressMonitor());

						// Copy file
						rres.copy(lres, EFS.OVERWRITE, monitor);
					} catch (IOException e) {
						throw new CoreException(new Status(IStatus.ERROR, PTPLaunchPlugin.PLUGIN_ID, 
								Messages.AbstractParallelLaunchConfigurationDelegate_Could_not_retrieve_remote_resource_info));
					}
	/*			}
			} else {
				// FIXME: work out what to do for RM's that don't extend AbstractRemoteResourceManagerConfiguration
			}
		}*/
	}

	/**
	 * Copy a data from a path (can be a file or directory) from the local host to
	 * the remote host.
	 *
	 * @param localPath
	 * @param remotePath
	 * @param configuration
	 * @throws CoreException
	 */
	protected void copyFileToRemoteHost(String localPath, String remotePath, ILaunchConfiguration configuration,
			IProgressMonitor monitor) throws CoreException {
					IRemoteFileManager localFileManager = getLocalFileManager(configuration);

					IRemoteFileManager remoteFileManager = getRemoteFileManager(configuration);

					try {
						IFileStore lres = localFileManager.getResource(new Path(localPath), new NullProgressMonitor());
						if(!lres.fetchInfo().exists()) {
							// Local file not found!
							throw new CoreException(new Status(IStatus.ERROR, PTPLaunchPlugin.PLUGIN_ID, 
									Messages.AbstractParallelLaunchConfigurationDelegate_Local_resource_does_not_exist));
						}
						IFileStore rres = remoteFileManager.getResource(new Path(remotePath), monitor);

						// Copy file
						lres.copy(rres, EFS.OVERWRITE, monitor);

					} catch (IOException e) {
						throw new CoreException(new Status(IStatus.ERROR, PTPLaunchPlugin.PLUGIN_ID, 
								Messages.AbstractParallelLaunchConfigurationDelegate_Could_not_retrieve_local_resource_info));
					}
	}

	/**
	 * Verify the working directory. If no working directory is specified, the default is
	 * the location of the executable.
	 *
	 * @param configuration
	 * @return
	 * @throws CoreException
	 */
	protected String verifyWorkDirectory(ILaunchConfiguration configuration) throws CoreException {
		IPath path;
        String workPath = getWorkDirectory(configuration);
        if (workPath == null) {
        	path = verifyExecutablePath(configuration).removeLastSegments(1);
		} else {
			path = verifyResource(workPath, configuration);
		}
		return path.toString();
    }

	/**
	 * This method does the synchronization step before the job submission
	 *
	 * @param configuration
	 * @param monitor
	 */
	protected void doPreLaunchSynchronization(ILaunchConfiguration configuration,
			IProgressMonitor monitor) throws CoreException {
		boolean syncBefore = configuration.getAttribute(
				IPTPLaunchConfigurationConstants.ATTR_SYNC_BEFORE, false);
		if(!syncBefore)
			return;

		// This faction generate action objects which execute according to rules
		RuleActionFactory ruleActFactory = new RuleActionFactory(configuration, this, monitor);

		List<?> rulesList = configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_SYNC_RULES, new ArrayList<String>());

		// Iterate over rules executing them
		for (Object ruleObj : rulesList) {
			ISynchronizationRule syncRule =
				RuleFactory.createRuleFromString((String)ruleObj);
			if(syncRule.isUploadRule()) {
				// Execute the action
				IRuleAction action = ruleActFactory.getAction(syncRule);
				action.run();
			}

		}
	}

	protected void doPosLaunchSynchronization(ILaunchConfiguration configuration)  throws CoreException {
		boolean syncAfter;
		syncAfter = configuration.getAttribute(
				IPTPLaunchConfigurationConstants.ATTR_SYNC_AFTER, false);
		if(!syncAfter)
			return;
		List<?> rulesList = configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_SYNC_RULES, new ArrayList<String>());

		// This faction generate action objects which execute according to rules
		RuleActionFactory ruleActFactory = new RuleActionFactory(configuration, this, new NullProgressMonitor());

		for (Object ruleObj : rulesList) {
			ISynchronizationRule syncRule =
				RuleFactory.createRuleFromString((String)ruleObj);
			if(syncRule.isDownloadRule()) {
				// Execute the action
				IRuleAction action = ruleActFactory.getAction(syncRule);
				action.run();
			}
		}
	}

	/**
	 * Returns the (possible empty) list of synchronization rule objects according to the rules described in the configuration.
	 */
	protected ISynchronizationRule[] getSynchronizeRules(ILaunchConfiguration configuration) throws CoreException {
		List<?> ruleStrings = configuration.getAttribute(IPTPLaunchConfigurationConstants.ATTR_SYNC_RULES, new ArrayList<String>());
		List<ISynchronizationRule> result = new ArrayList<ISynchronizationRule>();

		for (Object ruleObj : ruleStrings) {
			String element = (String) ruleObj;
			try {
				ISynchronizationRule rule = RuleFactory.createRuleFromString(element);
				result.add(rule);
			} catch (RuntimeException e) {
				throw new CoreException(new Status(Status.ERROR,
						PTPLaunchPlugin.PLUGIN_ID,
						Messages.AbstractParallelLaunchConfigurationDelegate_Error_converting_rules));
			}
		}

		return (ISynchronizationRule[]) result.toArray(new ISynchronizationRule[result.size()]);
	}

	// Methods below implement the ILaunchProcessCallback interface

	public void addSynchronizationRule(ISynchronizationRule rule) {
		extraSynchronizationRules.add(rule);
	}

	public IRemoteFileManager getLocalFileManager(ILaunchConfiguration configuration) throws CoreException {
		IResourceManagerControl rm = (IResourceManagerControl)getResourceManager(configuration);
		if (rm != null) {
			IResourceManagerConfiguration conf = rm.getConfiguration();
			if (conf instanceof AbstractRemoteResourceManagerConfiguration) {
				IRemoteServices localServices = PTPRemoteCorePlugin.getDefault().getRemoteServices("org.eclipse.ptp.remote.LocalServices"); //$NON-NLS-1$
				if (localServices != null) {
					IRemoteConnectionManager lconnMgr = localServices.getConnectionManager();
					IRemoteConnection lconn = lconnMgr.getConnection(null); // Since it's a local service, doesn't matter which parameter is passed
					IRemoteFileManager localFileManager = localServices.getFileManager(lconn);

					return localFileManager;
				}
			}
		}

		return null;
	}

	public IRemoteFileManager getRemoteFileManager(ILaunchConfiguration configuration) throws CoreException {
		IResourceManagerControl rm = (IResourceManagerControl)getResourceManager(configuration);
		if (rm != null) {
			IResourceManagerConfiguration conf = rm.getConfiguration();
			if (conf instanceof AbstractRemoteResourceManagerConfiguration) {
				AbstractRemoteResourceManagerConfiguration remConf = (AbstractRemoteResourceManagerConfiguration)conf;

				IRemoteServices remoteServices = PTPRemoteCorePlugin.getDefault().getRemoteServices(remConf.getRemoteServicesId());
				if (remoteServices != null) {

					IRemoteConnectionManager rconnMgr = remoteServices.getConnectionManager();
					IRemoteConnection rconn = rconnMgr.getConnection(remConf.getConnectionName());
					IRemoteFileManager remoteFileManager = remoteServices.getFileManager(rconn);

					return remoteFileManager;
				}
			}
		}
		return null;
	}

	protected static String [] getEnvironmentToAppend(ILaunchConfiguration configuration) throws CoreException {
		Map<?,?> defaultEnv = null;
		Map<?,?> configEnv = configuration.getAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES, defaultEnv);
		if (configEnv == null) {
			return null;
		}
		if (! configuration.getAttribute(ILaunchManager.ATTR_APPEND_ENVIRONMENT_VARIABLES, true)) {
			throw new CoreException(new Status(IStatus.ERROR, PTPLaunchPlugin.getUniqueIdentifier(), 
					Messages.AbstractParallelLaunchConfigurationDelegate_Parallel_launcher_does_not_support));
		}

		List<String> strings = new ArrayList<String>(configEnv.size());
		Iterator<?> iter= configEnv.entrySet().iterator();
		while (iter.hasNext()) {
			Entry<?,?> entry = (Entry<?, ?>) iter.next();
			String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            strings.add(key+"="+value); //$NON-NLS-1$

		}
		return strings.toArray(new String[strings.size()]);
	}

}