bundles/org.eclipse.rap.tools.launch/src/org/eclipse/rap/tools/launch/internal/RAPLaunchDelegate.java - rap/org.eclipse.rap.tools - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2013 EclipseSource 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:
  *    Innoopract Informationssysteme GmbH - initial API and implementation
  *    EclipseSource - ongoing development
  ******************************************************************************/
 package org.eclipse.rap.tools.launch.internal;

 import static java.util.Arrays.asList;
 import static org.eclipse.pde.internal.launching.launcher.LauncherUtils.clearWorkspace;

 import java.io.IOException;
 import java.net.*;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.core.runtime.*;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.core.variables.IStringVariableManager;
 import org.eclipse.core.variables.VariablesPlugin;
 import org.eclipse.debug.core.*;
 import org.eclipse.debug.core.model.RuntimeProcess;
 import org.eclipse.pde.launching.EquinoxLaunchConfiguration;
 import org.eclipse.rap.tools.launch.internal.RAPLaunchConfig.BrowserMode;
 import org.eclipse.rap.tools.launch.internal.util.ErrorUtil;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.ui.*;
 import org.eclipse.ui.browser.IWebBrowser;
 import org.eclipse.ui.browser.IWorkbenchBrowserSupport;


 public final class RAPLaunchDelegate extends EquinoxLaunchConfiguration {

   // VM argument contants
   private static final String VMARG_PORT
     = "-Dorg.osgi.service.http.port="; //$NON-NLS-1$
   private static final String VMARG_DEVELOPMENT_MODE
     = "-Dorg.eclipse.rap.rwt.developmentMode="; //$NON-NLS-1$
   private static final String VMARG_SESSION_TIMEOUT
     = "-Dorg.eclipse.equinox.http.jetty.context.sessioninactiveinterval="; //$NON-NLS-1$
   private static final String VMARG_CONTEXT_PATH
     = "-Dorg.eclipse.equinox.http.jetty.context.path="; //$NON-NLS-1$

   private static final int CONNECT_TIMEOUT = 20000; // 20 Seconds

   private ILaunch launch;
   private RAPLaunchConfig config;
   private int port;
   private final boolean testMode;

   public RAPLaunchDelegate() {
     this( false );
   }

   public RAPLaunchDelegate( boolean testMode ) {
     this.testMode = testMode;
   }

   @Override
   public void launch( ILaunchConfiguration config,
                       String mode,
                       ILaunch launch,
                       IProgressMonitor monitor )
     throws CoreException
   {
     SubProgressMonitor subMonitor = doPreLaunch( config, launch, monitor );
     super.launch( config, mode, launch, subMonitor );
   }

   public SubProgressMonitor doPreLaunch( ILaunchConfiguration config,
                                          ILaunch launch,
                                          IProgressMonitor monitor )
     throws CoreException
   {
     // As this is the first method that is called after creating an instance
     // of RAPLaunchDelegate, store the config and launch parameters to be
     // accessible from member methods
     // TODO [rh] find a better way
     this.launch = launch;
     this.config = new RAPLaunchConfig( config );
     SubProgressMonitor subMonitor;
     subMonitor = new SubProgressMonitor( monitor, IProgressMonitor.UNKNOWN );
     terminateIfRunning( subMonitor );
     subMonitor = new SubProgressMonitor( monitor, IProgressMonitor.UNKNOWN );
     warnIfPortBusy( subMonitor );
     subMonitor = new SubProgressMonitor( monitor, IProgressMonitor.UNKNOWN );
     port = determinePort( subMonitor );
     if( this.config.getOpenBrowser() ) {
       registerBrowserOpener();
     }
     return subMonitor;
   }

   @Override
   public String[] getVMArguments( ILaunchConfiguration config ) throws CoreException {
     List<String> list = new ArrayList<String>();
     // ORDER IS CRUCIAL HERE:
     // Override VM arguments that are specified manually with the values
     // necessary for the RAP launcher
     list.addAll( asList( super.getVMArguments( config ) ) );
     list.addAll( getRAPVMArguments() );
     return toStringArray( list );
   }

   @Override
   public String[] getProgramArguments( ILaunchConfiguration configuration ) throws CoreException {
     List<String> programArguments = new ArrayList<String>();
     programArguments.addAll( asList( super.getProgramArguments( configuration ) ) );
     String dataLocationResolved = getResolvedDataLoacation();
     if( dataLocationResolved.length() > 0 ) {
       programArguments.addAll( asList( "-data", dataLocationResolved ) );
     }
     return toStringArray( programArguments );
   }

   private String getResolvedDataLoacation() throws CoreException {
     String dataLocation = config.getDataLocation();
     return resolveVariables( dataLocation );
   }

   private String resolveVariables( String dataLocation ) throws CoreException {
     VariablesPlugin variablePlugin = VariablesPlugin.getDefault();
     IStringVariableManager stringVariableManager = variablePlugin.getStringVariableManager();
     return stringVariableManager.performStringSubstitution( dataLocation );
   }

   private List<String> getRAPVMArguments() throws CoreException {
     List<String> arguments = new ArrayList<String>();
     arguments.add( VMARG_PORT + port );
     arguments.add( VMARG_DEVELOPMENT_MODE + config.getDevelopmentMode() );
     if( config.getUseSessionTimeout() ) {
       arguments.add( VMARG_SESSION_TIMEOUT + config.getSessionTimeout() );
     } else {
       arguments.add( VMARG_SESSION_TIMEOUT + RAPLaunchConfig.MIN_SESSION_TIMEOUT );
     }
     if( config.getUseManualContextPath() ) {
       String contextPath = config.getContextPath();
       if( !contextPath.startsWith( URLBuilder.SLASH ) ) {
         contextPath = URLBuilder.SLASH + contextPath;
       }
       if( contextPath.endsWith( URLBuilder.SLASH ) ) {
         contextPath = contextPath.substring( 0, contextPath.length() - 1 );
       }
       arguments.add( VMARG_CONTEXT_PATH + contextPath );
     }
     return arguments;
   }

   private static String[] toStringArray( List<String> list ) {
     String[] result = new String[ list.size() ];
     list.toArray( result );
     return result;
   }

   private void warnIfPortBusy( SubProgressMonitor monitor ) throws CoreException {
     String taskName = LaunchMessages.RAPLaunchDelegate_CheckPortTaskName;
     monitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
     try {
       if( config.getUseManualPort() && isPortBusy( config.getPort() ) ) {
         DebugPlugin debugPlugin = DebugPlugin.getDefault();
         IStatusHandler prompter = debugPlugin.getStatusHandler( promptStatus );
         if( prompter != null ) {
           IStatus status = PortBusyStatusHandler.STATUS;
           Object resolution = prompter.handleStatus( status, config );
           if( Boolean.FALSE.equals( resolution ) ) {
             String text = LaunchMessages.RAPLaunchDelegate_PortInUse;
             Object[] args = new Object[] {
               new Integer( config.getPort() ),
               config.getName()
             };
             String msg = MessageFormat.format( text, args );
             String pluginId = Activator.PLUGIN_ID;
             Status infoStatus = new Status( IStatus.INFO, pluginId, msg );
             throw new CoreException( infoStatus );
           }
         }
       }
     } finally {
       monitor.done();
     }
   }

   private int determinePort( IProgressMonitor monitor ) throws CoreException {
     int result;
     String taskName = LaunchMessages.RAPLaunchDelegate_DeterminePortTaskName;
     monitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
     try {
       if( config.getUseManualPort() ) {
         result = config.getPort();
       } else {
         result = findFreePort();
       }
     } finally {
       monitor.done();
     }
     return result;
   }

   private static int findFreePort() throws CoreException {
     try {
       ServerSocket server = new ServerSocket( 0 );
       try {
         return server.getLocalPort();
       } finally {
         server.close();
       }
     } catch( IOException e ) {
       String msg = "Could not obtain a free port number."; //$NON-NLS-1$
       String pluginId = Activator.getPluginId();
       Status status = new Status( IStatus.ERROR, pluginId, msg, e );
       throw new CoreException( status );
     }
   }

   private static boolean isPortBusy( int port ) {
     ServerSocket server = null;
     try {
       server = new ServerSocket( port );
     } catch( IOException e1 ) {
       // assume that port is occupied when getting here
     }
     if( server != null ) {
       try {
         server.close();
       } catch( IOException e ) {
         // ignore
       }
     }
     return server == null;
   }

   private URL getUrl() throws CoreException {
     try {
       String url = URLBuilder.fromLaunchConfig( config, port, testMode );
       return new URL( url );
     } catch( MalformedURLException e ) {
       String msg = "Invalid URL."; //$NON-NLS-1$
       String pluginId = Activator.getPluginId();
       Status status = new Status( IStatus.ERROR, pluginId, 0, msg, e );
       throw new CoreException( status );
     }
   }

   private void terminateIfRunning( IProgressMonitor monitor ) throws CoreException {
     String taskName = LaunchMessages.RAPLaunchDelegate_TerminatePreviousTaskName;
     monitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
     try {
       ILaunch runningLaunch = findRunning();
       if( runningLaunch != null ) {
         terminate( runningLaunch );
       }
     } finally {
       monitor.done();
     }
   }

   private ILaunch findRunning() {
     ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager();
     ILaunch[] runningLaunches = launchManager.getLaunches();
     ILaunch result = null;
     for( int i = 0; result == null && i < runningLaunches.length; i++ ) {
       ILaunch runningLaunch = runningLaunches[ i ];
       if(    runningLaunch != launch
           && config.getName().equals( getLaunchName( runningLaunch ) )
           && !runningLaunch.isTerminated() )
       {
         result = runningLaunches[ i ];
       }
     }
     return result;
   }

   private static String getLaunchName( ILaunch launch ) {
     ILaunchConfiguration launchConfiguration = launch.getLaunchConfiguration();
     // the launch config might be null (e.g. if deleted) even though there
     // still exists a launch for that config
     return launchConfiguration == null ? null : launchConfiguration.getName();
   }

   private static void terminate( final ILaunch previousLaunch ) throws DebugException {
     final Object signal = new Object();
     final boolean[] terminated = { false };
     DebugPlugin debugPlugin = DebugPlugin.getDefault();
     debugPlugin.addDebugEventListener( new IDebugEventSetListener() {
       public void handleDebugEvents( DebugEvent[] events ) {
         for( DebugEvent event : events ) {
           if( isTerminateEventFor( event, previousLaunch ) ) {
             DebugPlugin.getDefault().removeDebugEventListener( this );
             synchronized( signal ) {
               terminated[ 0 ] = true;
               signal.notifyAll();
             }
           }
         }
       }
     } );
     previousLaunch.terminate();
     try {
       synchronized( signal ) {
         if( !terminated[ 0 ] ) {
           signal.wait();
         }
       }
     } catch( InterruptedException e ) {
       // ignore
     }
   }

   private static boolean isCreateEventFor( DebugEvent event, ILaunch launch ) {
     Object source = event.getSource();
     return    event.getKind() == DebugEvent.CREATE
            && source instanceof RuntimeProcess
            && ( ( RuntimeProcess ) source ).getLaunch() == launch;
   }

   private static boolean isTerminateEventFor( DebugEvent event, ILaunch launch ) {
     boolean result = false;
     if(    event.getKind() == DebugEvent.TERMINATE
         && event.getSource() instanceof RuntimeProcess )
     {
       RuntimeProcess process = ( RuntimeProcess )event.getSource();
       result = process.getLaunch() == launch;
     }
     return result;
   }

   private void waitForHttpService( IProgressMonitor monitor ) {
     SubProgressMonitor subMonitor = new SubProgressMonitor( monitor, 1 );
     String taskName = LaunchMessages.RAPLaunchDelegate_WaitForHTTPTaskName;
     subMonitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
     try {
       long start = System.currentTimeMillis();
       boolean canConnect = false;
       boolean interrupted = false;
       while(    System.currentTimeMillis() - start <= CONNECT_TIMEOUT
              && !canConnect
              && !interrupted
              && !monitor.isCanceled()
              && !launch.isTerminated() )
       {
         try {
           Socket socket = new Socket( URLBuilder.getHost(), port );
           socket.close();
           canConnect = true;
         } catch( Exception e ) {
           // http service not yet started - wait a bit
           try {
             Thread.sleep( 200 );
           } catch( InterruptedException ie ) {
             interrupted = true;
           }
         }
       }
     } finally {
       subMonitor.done();
     }
   }

   @Override
   public void clear( ILaunchConfiguration configuration, IProgressMonitor monitor )
     throws CoreException
   {
     clearDataLocation( configuration, monitor );
     super.clear( configuration, monitor );
   }

   private void clearDataLocation( ILaunchConfiguration configuration, IProgressMonitor monitor )
     throws CoreException
   {
     String resolvedDataLocation = getResolvedDataLoacation();
     boolean isCleared = clearWorkspace( configuration, resolvedDataLocation, monitor );
     if( !isCleared ) {
       throw new CoreException( Status.CANCEL_STATUS );
     }
   }

   private void registerBrowserOpener() {
     DebugPlugin debugPlugin = DebugPlugin.getDefault();
     debugPlugin.addDebugEventListener( new IDebugEventSetListener() {
       public void handleDebugEvents( DebugEvent[] events ) {
         for( DebugEvent event : events ) {
           if( isCreateEventFor( event, launch ) ) {
             DebugPlugin.getDefault().removeDebugEventListener( this );
             // Start a separate job to wait for the http service and launch the
             // browser. Otherwise we would block the application on whose
             // service we are waiting for
             final String jobTaskName = LaunchMessages.RAPLaunchDelegate_StartClientTaskName;
             Job job = new Job( jobTaskName ) {
               @Override
               protected IStatus run( IProgressMonitor monitor ) {
                 String taskName = jobTaskName;
                 monitor.beginTask( taskName, 2 );
                 try {
                   waitForHttpService( monitor );
                   monitor.worked( 1 );
                   if( !launch.isTerminated() ) {
                     openBrowser( monitor );
                   }
                 } finally {
                   monitor.done();
                 }
                 return Status.OK_STATUS;
               }
             };
             job.schedule();
           }
         }
       }
     } );
   }

   private void openBrowser( IProgressMonitor monitor ) {
     SubProgressMonitor subMonitor = new SubProgressMonitor( monitor, 1 );
     String taskName = LaunchMessages.RAPLaunchDelegate_StartClientTaskName;
     subMonitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
     try {
       URL url = null;
       try {
         url = getUrl();
         IWebBrowser browser = getBrowser();
         openUrl( browser, url );
       } catch( CoreException e ) {
         String text = LaunchMessages.RAPLaunchDelegate_OpenBrowserFailed;
         String msg = MessageFormat.format( text, new Object[]{ url } );
         ErrorUtil.show( msg, e );
       }
     } finally {
       subMonitor.done();
     }
   }

   private IWebBrowser getBrowser() throws CoreException {
     final IWebBrowser[] result = { null };
     final CoreException[] exception = { null };
     Display.getDefault().syncExec( new Runnable() {
       public void run() {
         try {
           IWorkbench workbench = PlatformUI.getWorkbench();
           IWorkbenchBrowserSupport support = workbench.getBrowserSupport();
           int style = IWorkbenchBrowserSupport.LOCATION_BAR
                     | IWorkbenchBrowserSupport.NAVIGATION_BAR
                     | IWorkbenchBrowserSupport.STATUS;
           if( BrowserMode.EXTERNAL.equals( config.getBrowserMode() ) ) {
             style |= IWorkbenchBrowserSupport.AS_EXTERNAL;
           } else {
             style |= IWorkbenchBrowserSupport.AS_EDITOR;
           }
           // Starting the same launch first with the external, then with the
           // internal browser without restarting the workbench will still open
           // an external browser.
           // The fix is to append the browserMode to the id
           String id = config.getName() + config.getBrowserMode();
           String name = config.getName();
           String toolTip = config.getName();
           result[ 0 ] = support.createBrowser( style, id, name, toolTip );
         } catch( CoreException e ) {
           exception[ 0 ] = e;
         }
       }
     } );
     if( exception[ 0 ] != null ) {
       throw exception[ 0 ];
     }
     return result[ 0 ];
   }

   private static void openUrl( final IWebBrowser browser, final URL url ) throws PartInitException {
     final PartInitException[] exception = { null };
     Display.getDefault().asyncExec( new Runnable() {
       public void run() {
         try {
           browser.openURL( url );
         } catch( PartInitException e ) {
           String text = LaunchMessages.RAPLaunchDelegate_OpenUrlFailed;
           String msg = MessageFormat.format( text, new Object[] { url } );
           String pluginId = Activator.getPluginId();
           Status status = new Status( IStatus.ERROR, pluginId, msg, e );
           exception[ 0 ] = new PartInitException( status );
         }
       }
     } );
     if( exception[ 0 ] != null ) {
       throw exception[ 0 ];
     }
   }

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2013 EclipseSource 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:
	* Innoopract Informationssysteme GmbH - initial API and implementation
	* EclipseSource - ongoing development
	******************************************************************************/
	package org.eclipse.rap.tools.launch.internal;

	import static java.util.Arrays.asList;
	import static org.eclipse.pde.internal.launching.launcher.LauncherUtils.clearWorkspace;

	import java.io.IOException;
	import java.net.*;
	import java.text.MessageFormat;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.core.runtime.*;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.core.variables.IStringVariableManager;
	import org.eclipse.core.variables.VariablesPlugin;
	import org.eclipse.debug.core.*;
	import org.eclipse.debug.core.model.RuntimeProcess;
	import org.eclipse.pde.launching.EquinoxLaunchConfiguration;
	import org.eclipse.rap.tools.launch.internal.RAPLaunchConfig.BrowserMode;
	import org.eclipse.rap.tools.launch.internal.util.ErrorUtil;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.ui.*;
	import org.eclipse.ui.browser.IWebBrowser;
	import org.eclipse.ui.browser.IWorkbenchBrowserSupport;


	public final class RAPLaunchDelegate extends EquinoxLaunchConfiguration {

	// VM argument contants
	private static final String VMARG_PORT
	= "-Dorg.osgi.service.http.port="; //$NON-NLS-1$
	private static final String VMARG_DEVELOPMENT_MODE
	= "-Dorg.eclipse.rap.rwt.developmentMode="; //$NON-NLS-1$
	private static final String VMARG_SESSION_TIMEOUT
	= "-Dorg.eclipse.equinox.http.jetty.context.sessioninactiveinterval="; //$NON-NLS-1$
	private static final String VMARG_CONTEXT_PATH
	= "-Dorg.eclipse.equinox.http.jetty.context.path="; //$NON-NLS-1$

	private static final int CONNECT_TIMEOUT = 20000; // 20 Seconds

	private ILaunch launch;
	private RAPLaunchConfig config;
	private int port;
	private final boolean testMode;

	public RAPLaunchDelegate() {
	this( false );
	}

	public RAPLaunchDelegate( boolean testMode ) {
	this.testMode = testMode;
	}

	@Override
	public void launch( ILaunchConfiguration config,
	String mode,
	ILaunch launch,
	IProgressMonitor monitor )
	throws CoreException
	{
	SubProgressMonitor subMonitor = doPreLaunch( config, launch, monitor );
	super.launch( config, mode, launch, subMonitor );
	}

	public SubProgressMonitor doPreLaunch( ILaunchConfiguration config,
	ILaunch launch,
	IProgressMonitor monitor )
	throws CoreException
	{
	// As this is the first method that is called after creating an instance
	// of RAPLaunchDelegate, store the config and launch parameters to be
	// accessible from member methods
	// TODO [rh] find a better way
	this.launch = launch;
	this.config = new RAPLaunchConfig( config );
	SubProgressMonitor subMonitor;
	subMonitor = new SubProgressMonitor( monitor, IProgressMonitor.UNKNOWN );
	terminateIfRunning( subMonitor );
	subMonitor = new SubProgressMonitor( monitor, IProgressMonitor.UNKNOWN );
	warnIfPortBusy( subMonitor );
	subMonitor = new SubProgressMonitor( monitor, IProgressMonitor.UNKNOWN );
	port = determinePort( subMonitor );
	if( this.config.getOpenBrowser() ) {
	registerBrowserOpener();
	}
	return subMonitor;
	}

	@Override
	public String[] getVMArguments( ILaunchConfiguration config ) throws CoreException {
	List<String> list = new ArrayList<String>();
	// ORDER IS CRUCIAL HERE:
	// Override VM arguments that are specified manually with the values
	// necessary for the RAP launcher
	list.addAll( asList( super.getVMArguments( config ) ) );
	list.addAll( getRAPVMArguments() );
	return toStringArray( list );
	}

	@Override
	public String[] getProgramArguments( ILaunchConfiguration configuration ) throws CoreException {
	List<String> programArguments = new ArrayList<String>();
	programArguments.addAll( asList( super.getProgramArguments( configuration ) ) );
	String dataLocationResolved = getResolvedDataLoacation();
	if( dataLocationResolved.length() > 0 ) {
	programArguments.addAll( asList( "-data", dataLocationResolved ) );
	}
	return toStringArray( programArguments );
	}

	private String getResolvedDataLoacation() throws CoreException {
	String dataLocation = config.getDataLocation();
	return resolveVariables( dataLocation );
	}

	private String resolveVariables( String dataLocation ) throws CoreException {
	VariablesPlugin variablePlugin = VariablesPlugin.getDefault();
	IStringVariableManager stringVariableManager = variablePlugin.getStringVariableManager();
	return stringVariableManager.performStringSubstitution( dataLocation );
	}

	private List<String> getRAPVMArguments() throws CoreException {
	List<String> arguments = new ArrayList<String>();
	arguments.add( VMARG_PORT + port );
	arguments.add( VMARG_DEVELOPMENT_MODE + config.getDevelopmentMode() );
	if( config.getUseSessionTimeout() ) {
	arguments.add( VMARG_SESSION_TIMEOUT + config.getSessionTimeout() );
	} else {
	arguments.add( VMARG_SESSION_TIMEOUT + RAPLaunchConfig.MIN_SESSION_TIMEOUT );
	}
	if( config.getUseManualContextPath() ) {
	String contextPath = config.getContextPath();
	if( !contextPath.startsWith( URLBuilder.SLASH ) ) {
	contextPath = URLBuilder.SLASH + contextPath;
	}
	if( contextPath.endsWith( URLBuilder.SLASH ) ) {
	contextPath = contextPath.substring( 0, contextPath.length() - 1 );
	}
	arguments.add( VMARG_CONTEXT_PATH + contextPath );
	}
	return arguments;
	}

	private static String[] toStringArray( List<String> list ) {
	String[] result = new String[ list.size() ];
	list.toArray( result );
	return result;
	}

	private void warnIfPortBusy( SubProgressMonitor monitor ) throws CoreException {
	String taskName = LaunchMessages.RAPLaunchDelegate_CheckPortTaskName;
	monitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
	try {
	if( config.getUseManualPort() && isPortBusy( config.getPort() ) ) {
	DebugPlugin debugPlugin = DebugPlugin.getDefault();
	IStatusHandler prompter = debugPlugin.getStatusHandler( promptStatus );
	if( prompter != null ) {
	IStatus status = PortBusyStatusHandler.STATUS;
	Object resolution = prompter.handleStatus( status, config );
	if( Boolean.FALSE.equals( resolution ) ) {
	String text = LaunchMessages.RAPLaunchDelegate_PortInUse;
	Object[] args = new Object[] {
	new Integer( config.getPort() ),
	config.getName()
	};
	String msg = MessageFormat.format( text, args );
	String pluginId = Activator.PLUGIN_ID;
	Status infoStatus = new Status( IStatus.INFO, pluginId, msg );
	throw new CoreException( infoStatus );
	}
	}
	}
	} finally {
	monitor.done();
	}
	}

	private int determinePort( IProgressMonitor monitor ) throws CoreException {
	int result;
	String taskName = LaunchMessages.RAPLaunchDelegate_DeterminePortTaskName;
	monitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
	try {
	if( config.getUseManualPort() ) {
	result = config.getPort();
	} else {
	result = findFreePort();
	}
	} finally {
	monitor.done();
	}
	return result;
	}

	private static int findFreePort() throws CoreException {
	try {
	ServerSocket server = new ServerSocket( 0 );
	try {
	return server.getLocalPort();
	} finally {
	server.close();
	}
	} catch( IOException e ) {
	String msg = "Could not obtain a free port number."; //$NON-NLS-1$
	String pluginId = Activator.getPluginId();
	Status status = new Status( IStatus.ERROR, pluginId, msg, e );
	throw new CoreException( status );
	}
	}

	private static boolean isPortBusy( int port ) {
	ServerSocket server = null;
	try {
	server = new ServerSocket( port );
	} catch( IOException e1 ) {
	// assume that port is occupied when getting here
	}
	if( server != null ) {
	try {
	server.close();
	} catch( IOException e ) {
	// ignore
	}
	}
	return server == null;
	}

	private URL getUrl() throws CoreException {
	try {
	String url = URLBuilder.fromLaunchConfig( config, port, testMode );
	return new URL( url );
	} catch( MalformedURLException e ) {
	String msg = "Invalid URL."; //$NON-NLS-1$
	String pluginId = Activator.getPluginId();
	Status status = new Status( IStatus.ERROR, pluginId, 0, msg, e );
	throw new CoreException( status );
	}
	}

	private void terminateIfRunning( IProgressMonitor monitor ) throws CoreException {
	String taskName = LaunchMessages.RAPLaunchDelegate_TerminatePreviousTaskName;
	monitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
	try {
	ILaunch runningLaunch = findRunning();
	if( runningLaunch != null ) {
	terminate( runningLaunch );
	}
	} finally {
	monitor.done();
	}
	}

	private ILaunch findRunning() {
	ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager();
	ILaunch[] runningLaunches = launchManager.getLaunches();
	ILaunch result = null;
	for( int i = 0; result == null && i < runningLaunches.length; i++ ) {
	ILaunch runningLaunch = runningLaunches[ i ];
	if( runningLaunch != launch
	&& config.getName().equals( getLaunchName( runningLaunch ) )
	&& !runningLaunch.isTerminated() )
	{
	result = runningLaunches[ i ];
	}
	}
	return result;
	}

	private static String getLaunchName( ILaunch launch ) {
	ILaunchConfiguration launchConfiguration = launch.getLaunchConfiguration();
	// the launch config might be null (e.g. if deleted) even though there
	// still exists a launch for that config
	return launchConfiguration == null ? null : launchConfiguration.getName();
	}

	private static void terminate( final ILaunch previousLaunch ) throws DebugException {
	final Object signal = new Object();
	final boolean[] terminated = { false };
	DebugPlugin debugPlugin = DebugPlugin.getDefault();
	debugPlugin.addDebugEventListener( new IDebugEventSetListener() {
	public void handleDebugEvents( DebugEvent[] events ) {
	for( DebugEvent event : events ) {
	if( isTerminateEventFor( event, previousLaunch ) ) {
	DebugPlugin.getDefault().removeDebugEventListener( this );
	synchronized( signal ) {
	terminated[ 0 ] = true;
	signal.notifyAll();
	}
	}
	}
	}
	} );
	previousLaunch.terminate();
	try {
	synchronized( signal ) {
	if( !terminated[ 0 ] ) {
	signal.wait();
	}
	}
	} catch( InterruptedException e ) {
	// ignore
	}
	}

	private static boolean isCreateEventFor( DebugEvent event, ILaunch launch ) {
	Object source = event.getSource();
	return event.getKind() == DebugEvent.CREATE
	&& source instanceof RuntimeProcess
	&& ( ( RuntimeProcess ) source ).getLaunch() == launch;
	}

	private static boolean isTerminateEventFor( DebugEvent event, ILaunch launch ) {
	boolean result = false;
	if( event.getKind() == DebugEvent.TERMINATE
	&& event.getSource() instanceof RuntimeProcess )
	{
	RuntimeProcess process = ( RuntimeProcess )event.getSource();
	result = process.getLaunch() == launch;
	}
	return result;
	}

	private void waitForHttpService( IProgressMonitor monitor ) {
	SubProgressMonitor subMonitor = new SubProgressMonitor( monitor, 1 );
	String taskName = LaunchMessages.RAPLaunchDelegate_WaitForHTTPTaskName;
	subMonitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
	try {
	long start = System.currentTimeMillis();
	boolean canConnect = false;
	boolean interrupted = false;
	while( System.currentTimeMillis() - start <= CONNECT_TIMEOUT
	&& !canConnect
	&& !interrupted
	&& !monitor.isCanceled()
	&& !launch.isTerminated() )
	{
	try {
	Socket socket = new Socket( URLBuilder.getHost(), port );
	socket.close();
	canConnect = true;
	} catch( Exception e ) {
	// http service not yet started - wait a bit
	try {
	Thread.sleep( 200 );
	} catch( InterruptedException ie ) {
	interrupted = true;
	}
	}
	}
	} finally {
	subMonitor.done();
	}
	}

	@Override
	public void clear( ILaunchConfiguration configuration, IProgressMonitor monitor )
	throws CoreException
	{
	clearDataLocation( configuration, monitor );
	super.clear( configuration, monitor );
	}

	private void clearDataLocation( ILaunchConfiguration configuration, IProgressMonitor monitor )
	throws CoreException
	{
	String resolvedDataLocation = getResolvedDataLoacation();
	boolean isCleared = clearWorkspace( configuration, resolvedDataLocation, monitor );
	if( !isCleared ) {
	throw new CoreException( Status.CANCEL_STATUS );
	}
	}

	private void registerBrowserOpener() {
	DebugPlugin debugPlugin = DebugPlugin.getDefault();
	debugPlugin.addDebugEventListener( new IDebugEventSetListener() {
	public void handleDebugEvents( DebugEvent[] events ) {
	for( DebugEvent event : events ) {
	if( isCreateEventFor( event, launch ) ) {
	DebugPlugin.getDefault().removeDebugEventListener( this );
	// Start a separate job to wait for the http service and launch the
	// browser. Otherwise we would block the application on whose
	// service we are waiting for
	final String jobTaskName = LaunchMessages.RAPLaunchDelegate_StartClientTaskName;
	Job job = new Job( jobTaskName ) {
	@Override
	protected IStatus run( IProgressMonitor monitor ) {
	String taskName = jobTaskName;
	monitor.beginTask( taskName, 2 );
	try {
	waitForHttpService( monitor );
	monitor.worked( 1 );
	if( !launch.isTerminated() ) {
	openBrowser( monitor );
	}
	} finally {
	monitor.done();
	}
	return Status.OK_STATUS;
	}
	};
	job.schedule();
	}
	}
	}
	} );
	}

	private void openBrowser( IProgressMonitor monitor ) {
	SubProgressMonitor subMonitor = new SubProgressMonitor( monitor, 1 );
	String taskName = LaunchMessages.RAPLaunchDelegate_StartClientTaskName;
	subMonitor.beginTask( taskName, IProgressMonitor.UNKNOWN );
	try {
	URL url = null;
	try {
	url = getUrl();
	IWebBrowser browser = getBrowser();
	openUrl( browser, url );
	} catch( CoreException e ) {
	String text = LaunchMessages.RAPLaunchDelegate_OpenBrowserFailed;
	String msg = MessageFormat.format( text, new Object[]{ url } );
	ErrorUtil.show( msg, e );
	}
	} finally {
	subMonitor.done();
	}
	}

	private IWebBrowser getBrowser() throws CoreException {
	final IWebBrowser[] result = { null };
	final CoreException[] exception = { null };
	Display.getDefault().syncExec( new Runnable() {
	public void run() {
	try {
	IWorkbench workbench = PlatformUI.getWorkbench();
	IWorkbenchBrowserSupport support = workbench.getBrowserSupport();
	int style = IWorkbenchBrowserSupport.LOCATION_BAR
	\| IWorkbenchBrowserSupport.NAVIGATION_BAR
	\| IWorkbenchBrowserSupport.STATUS;
	if( BrowserMode.EXTERNAL.equals( config.getBrowserMode() ) ) {
	style \|= IWorkbenchBrowserSupport.AS_EXTERNAL;
	} else {
	style \|= IWorkbenchBrowserSupport.AS_EDITOR;
	}
	// Starting the same launch first with the external, then with the
	// internal browser without restarting the workbench will still open
	// an external browser.
	// The fix is to append the browserMode to the id
	String id = config.getName() + config.getBrowserMode();
	String name = config.getName();
	String toolTip = config.getName();
	result[ 0 ] = support.createBrowser( style, id, name, toolTip );
	} catch( CoreException e ) {
	exception[ 0 ] = e;
	}
	}
	} );
	if( exception[ 0 ] != null ) {
	throw exception[ 0 ];
	}
	return result[ 0 ];
	}

	private static void openUrl( final IWebBrowser browser, final URL url ) throws PartInitException {
	final PartInitException[] exception = { null };
	Display.getDefault().asyncExec( new Runnable() {
	public void run() {
	try {
	browser.openURL( url );
	} catch( PartInitException e ) {
	String text = LaunchMessages.RAPLaunchDelegate_OpenUrlFailed;
	String msg = MessageFormat.format( text, new Object[] { url } );
	String pluginId = Activator.getPluginId();
	Status status = new Status( IStatus.ERROR, pluginId, msg, e );
	exception[ 0 ] = new PartInitException( status );
	}
	}
	} );
	if( exception[ 0 ] != null ) {
	throw exception[ 0 ];
	}
	}

	}