net.sourceforge.phpeclipse.externaltools/src/net/sourceforge/phpdt/externaltools/launchConfigurations/ExternalToolsUtil.java

   1 package net.sourceforge.phpdt.externaltools.launchConfigurations;
   2
   3 /**********************************************************************
   4  Copyright (c) 2002 IBM Corp. and others. All rights reserved.
   5  This file is made available under the terms of the Common Public License v1.0
   6  which accompanies this distribution, and is available at
   7  http://www.eclipse.org/legal/cpl-v10.html
   8  �
   9  Contributors:
  10  **********************************************************************/
  11
  12 import java.io.File;
  13 import java.text.MessageFormat;
  14 //import java.util.Map;
  15
  16 import net.sourceforge.phpdt.externaltools.internal.model.ExternalToolsModelMessages;
  17 import net.sourceforge.phpdt.externaltools.internal.model.VariableContextManager;
  18 //import net.sourceforge.phpdt.externaltools.internal.registry.ExternalToolMigration;
  19 import net.sourceforge.phpdt.externaltools.internal.registry.RefreshScopeVariable;
  20 import net.sourceforge.phpdt.externaltools.internal.registry.RefreshScopeVariableRegistry;
  21 import net.sourceforge.phpdt.externaltools.model.IExternalToolConstants;
  22 import net.sourceforge.phpdt.externaltools.model.ToolUtil;
  23 import net.sourceforge.phpdt.externaltools.variable.ExpandVariableContext;
  24 import net.sourceforge.phpeclipse.externaltools.ExternalToolsPlugin;
  25
  26 import org.eclipse.jface.dialogs.MessageDialog;
  27 import org.eclipse.ui.IWorkbenchWindow;
  28 import org.eclipse.ui.PlatformUI;
  29 import org.eclipse.core.resources.IResource;
  30 import org.eclipse.core.runtime.CoreException;
  31 import org.eclipse.core.runtime.IPath;
  32 import org.eclipse.core.runtime.IProgressMonitor;
  33 import org.eclipse.core.runtime.IStatus;
  34 import org.eclipse.core.runtime.MultiStatus;
  35 import org.eclipse.core.runtime.Path;
  36 import org.eclipse.core.runtime.Status;
  37 import org.eclipse.debug.core.DebugPlugin;
  38 import org.eclipse.debug.core.ILaunchConfiguration;
  39 import org.eclipse.debug.core.ILaunchConfigurationType;
  40 import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
  41 import org.eclipse.debug.core.ILaunchManager;
  42
  43 /**
  44  * Utilities for external tool launch configurations.
  45  * <p>
  46  * This class it not intended to be instantiated.
  47  * </p>
  48  */
  49 public class ExternalToolsUtil {
  50
  51         //private static final String LAUNCH_CONFIG_HANDLE = "LaunchConfigHandle"; //$NON-NLS-1$
  52
  53         /**
  54          * Not to be instantiated.
  55          */
  56         private ExternalToolsUtil() {
  57         };
  58
  59         /**
  60          * Throws a core exception with an error status object built from the given
  61          * message, lower level exception, and error code.
  62          *
  63          * @param message
  64          *            the status message
  65          * @param exception
  66          *            lower level exception associated with the error, or
  67          *            <code>null</code> if none
  68          * @param code
  69          *            error code
  70          */
  71         protected static void abort(String message, Throwable exception, int code)
  72                         throws CoreException {
  73                 throw new CoreException(new Status(IStatus.ERROR,
  74                                 IExternalToolConstants.PLUGIN_ID, code, message, exception));
  75         }
  76
  77         /**
  78          * Returns active variable context. The active variable context is used to
  79          * expand variable expressions. If the workspace is currently being built,
  80          * the context is associated with the project being built. Otherwise, the
  81          * context is associated with the selected resource.
  82          *
  83          * @return active variable context
  84          */
  85         public static ExpandVariableContext getVariableContext() {
  86                 return VariableContextManager.getDefault().getVariableContext();
  87         }
  88
  89         /**
  90          * Expands and returns the location attribute of the given launch
  91          * configuration, based on the given variable context. The location is
  92          * verified to point to an existing file, in the local file system.
  93          *
  94          * @param configuration
  95          *            launch configuration
  96          * @param context
  97          *            context used to expand variables
  98          * @return an absolute path to a file in the local file system
  99          * @throws CoreException
 100          *             if unable to retrieve the associated launch configuration
 101          *             attribute, if unable to resolve any variables, or if the
 102          *             resolved location does not point to an existing file in the
 103          *             local file system
 104          */
 105         public static IPath getLocation(ILaunchConfiguration configuration,
 106                         ExpandVariableContext context) throws CoreException {
 107                 String location = configuration.getAttribute(
 108                                 IExternalToolConstants.ATTR_LOCATION, (String) null);
 109                 if (location == null) {
 110                         abort(
 111                                         MessageFormat
 112                                                         .format(
 113                                                                         ExternalToolsLaunchConfigurationMessages
 114                                                                                         .getString("ExternalToolsUtil.Location_not_specified_by_{0}_1"), new String[] { configuration.getName() }), null, 0); //$NON-NLS-1$
 115                 } else {
 116                         MultiStatus status = new MultiStatus(
 117                                         IExternalToolConstants.PLUGIN_ID,
 118                                         0,
 119                                         ExternalToolsModelMessages
 120                                                         .getString("RunExternalToolAction.runProblem"), null); //$NON-NLS-1$;
 121                         String expandedLocation = ToolUtil.expandFileLocation(location,
 122                                         context, status);
 123                         if (status.isOK()) {
 124                                 if (expandedLocation == null || expandedLocation.length() == 0) {
 125                                         String msg = ExternalToolsModelMessages
 126                                                         .format(
 127                                                                         "DefaultRunnerContext.invalidLocation", new Object[] { configuration.getName() }); //$NON-NLS-1$
 128                                         abort(msg, null, 0);
 129                                 } else {
 130                                         File file = new File(expandedLocation);
 131                                         if (file.isFile()) {
 132                                                 return new Path(expandedLocation);
 133                                         } else {
 134                                                 String msg = ExternalToolsModelMessages
 135                                                                 .format(
 136                                                                                 "DefaultRunnerContext.invalidLocation", new Object[] { configuration.getName() }); //$NON-NLS-1$
 137                                                 abort(msg, null, 0);
 138                                         }
 139                                 }
 140                         } else {
 141                                 throw new CoreException(status);
 142                         }
 143                 }
 144                 // execution will not reach here
 145                 return null;
 146         }
 147
 148         /**
 149          * Expands and returns the working directory attribute of the given launch
 150          * configuration, based on the given variable context. Returns
 151          * <code>null</code> if a working directory is not specified. If
 152          * specified, the working is verified to point to an existing directory in
 153          * the local file system.
 154          *
 155          * @param configuration
 156          *            launch configuration
 157          * @param context
 158          *            context used to expand variables
 159          * @return an absolute path to a direcoty in the local file system, or
 160          *         <code>null</code> if unspecified
 161          * @throws CoreException
 162          *             if unable to retrieve the associated launch configuration
 163          *             attribute, if unable to resolve any variables, or if the
 164          *             resolved location does not point to an existing directory in
 165          *             the local file system
 166          */
 167         public static IPath getWorkingDirectory(ILaunchConfiguration configuration,
 168                         ExpandVariableContext context) throws CoreException {
 169                 String location = configuration.getAttribute(
 170                                 IExternalToolConstants.ATTR_WORKING_DIRECTORY, (String) null);
 171                 if (location != null) {
 172                         MultiStatus status = new MultiStatus(
 173                                         IExternalToolConstants.PLUGIN_ID,
 174                                         0,
 175                                         ExternalToolsModelMessages
 176                                                         .getString("RunExternalToolAction.runProblem"), null); //$NON-NLS-1$;
 177                         String expandedLocation = ToolUtil.expandDirectoryLocation(
 178                                         location, context, status);
 179                         if (status.isOK()) {
 180                                 if (expandedLocation != null && expandedLocation.length() > 0) {
 181                                         File path = new File(expandedLocation);
 182                                         if (path.isDirectory()) {
 183                                                 return new Path(expandedLocation);
 184                                         } else {
 185                                                 String msg = ExternalToolsModelMessages
 186                                                                 .format(
 187                                                                                 "DefaultRunnerContext.invalidDirectory", new Object[] { configuration.getName() }); //$NON-NLS-1$
 188                                                 abort(msg, null, 0);
 189                                         }
 190                                 }
 191                         } else {
 192                                 throw new CoreException(status);
 193                         }
 194                 }
 195                 return null;
 196         }
 197
 198         /**
 199          * Expands and returns the arguments attribute of the given launch
 200          * configuration, based on the given variable context. Returns
 201          * <code>null</code> if arguments are not specified.
 202          *
 203          * @param configuration
 204          *            launch configuration
 205          * @param context
 206          *            context used to expand variables
 207          * @return an array of resolved arguments, or <code>null</code> if
 208          *         unspecified
 209          * @throws CoreException
 210          *             if unable to retrieve the associated launch configuration
 211          *             attribute, or if unable to resolve any variables
 212          */
 213         public static String[] getArguments(ILaunchConfiguration configuration,
 214                         ExpandVariableContext context) throws CoreException {
 215                 String args = configuration.getAttribute(
 216                                 IExternalToolConstants.ATTR_TOOL_ARGUMENTS, (String) null);
 217                 if (args != null) {
 218                         MultiStatus status = new MultiStatus(
 219                                         IExternalToolConstants.PLUGIN_ID,
 220                                         0,
 221                                         ExternalToolsModelMessages
 222                                                         .getString("RunExternalToolAction.runProblem"), null); //$NON-NLS-1$;
 223                         String[] expandedArgs = ToolUtil.expandArguments(args, context,
 224                                         status);
 225                         if (status.isOK()) {
 226                                 return expandedArgs;
 227                         } else {
 228                                 throw new CoreException(status);
 229                         }
 230                 }
 231                 return null;
 232         }
 233
 234         /**
 235          * Returns the refresh scope specified by the given launch configuration or
 236          * <code>null</code> if none.
 237          *
 238          * @param configuration
 239          * @return refresh scope
 240          * @throws CoreException
 241          *             if unable to access the associated attribute
 242          */
 243         public static String getRefreshScope(ILaunchConfiguration configuration)
 244                         throws CoreException {
 245                 return configuration.getAttribute(
 246                                 IExternalToolConstants.ATTR_REFRESH_SCOPE, (String) null);
 247         }
 248
 249         /**
 250          * Returns whether the refresh scope specified by the given launch
 251          * configuration is recursive.
 252          *
 253          * @param configuration
 254          * @return whether the refresh scope is recursive
 255          * @throws CoreException
 256          *             if unable to access the associated attribute
 257          */
 258         public static boolean isRefreshRecursive(ILaunchConfiguration configuration)
 259                         throws CoreException {
 260                 return configuration.getAttribute(
 261                                 IExternalToolConstants.ATTR_REFRESH_RECURSIVE, false);
 262         }
 263
 264         /**
 265          * Refreshes the resources as specified by the given launch configuration.
 266          *
 267          * @param configuration
 268          *            launch configuration
 269          * @param context
 270          *            context used to expand variables
 271          * @param monitor
 272          *            progress monitor
 273          * @throws CoreException
 274          *             if an exception occurrs while refreshing resources
 275          */
 276         public static void refreshResources(ILaunchConfiguration configuration,
 277                         ExpandVariableContext context, IProgressMonitor monitor)
 278                         throws CoreException {
 279                 String scope = getRefreshScope(configuration);
 280                 if (scope == null)
 281                         return;
 282
 283                 ToolUtil.VariableDefinition varDef = ToolUtil.extractVariableTag(scope,
 284                                 0);
 285                 if (varDef.start == -1 || varDef.end == -1 || varDef.name == null) {
 286                         String msg = ExternalToolsModelMessages
 287                                         .format(
 288                                                         "DefaultRunnerContext.invalidRefreshVarFormat", new Object[] { configuration.getName() }); //$NON-NLS-1$
 289                         abort(msg, null, 0);
 290                 }
 291
 292                 RefreshScopeVariableRegistry registry = ExternalToolsPlugin
 293                                 .getDefault().getRefreshVariableRegistry();
 294                 RefreshScopeVariable variable = registry
 295                                 .getRefreshVariable(varDef.name);
 296                 if (variable == null) {
 297                         String msg = ExternalToolsModelMessages
 298                                         .format(
 299                                                         "DefaultRunnerContext.noRefreshVarNamed", new Object[] { configuration.getName(), varDef.name }); //$NON-NLS-1$
 300                         abort(msg, null, 0);
 301                 }
 302
 303                 int depth = IResource.DEPTH_ZERO;
 304                 if (isRefreshRecursive(configuration))
 305                         depth = IResource.DEPTH_INFINITE;
 306
 307                 if (monitor.isCanceled())
 308                         return;
 309
 310                 IResource[] resources = variable.getExpander().getResources(
 311                                 varDef.name, varDef.argument, context);
 312                 if (resources == null || resources.length == 0)
 313                         return;
 314
 315                 monitor.beginTask(ExternalToolsModelMessages
 316                                 .getString("DefaultRunnerContext.refreshResources"), //$NON-NLS-1$
 317                                 resources.length);
 318
 319                 MultiStatus status = new MultiStatus(
 320                                 IExternalToolConstants.PLUGIN_ID,
 321                                 0,
 322                                 ExternalToolsLaunchConfigurationMessages
 323                                                 .getString("ExternalToolsUtil.Exception(s)_occurred_during_refresh._2"), null); //$NON-NLS-1$
 324                 for (int i = 0; i < resources.length; i++) {
 325                         if (monitor.isCanceled())
 326                                 break;
 327                         if (resources[i] != null && resources[i].isAccessible()) {
 328                                 try {
 329                                         resources[i].refreshLocal(depth, null);
 330                                 } catch (CoreException e) {
 331                                         status.merge(e.getStatus());
 332                                 }
 333                         }
 334                         monitor.worked(1);
 335                 }
 336
 337                 monitor.done();
 338                 if (!status.isOK()) {
 339                         throw new CoreException(status);
 340                 }
 341         }
 342
 343         /**
 344          * Returns whether this tool is to be run in the background..
 345          *
 346          * @param configuration
 347          * @return whether this tool is to be run in the background
 348          * @throws CoreException
 349          *             if unable to access the associated attribute
 350          */
 351         public static boolean isBackground(ILaunchConfiguration configuration)
 352                         throws CoreException {
 353                 return configuration.getAttribute(
 354                                 IExternalToolConstants.ATTR_RUN_IN_BACKGROUND, false);
 355         }
 356
 357         /**
 358          * Returns a launch configuration from the given ICommand arguments. If the
 359          * given arguments are from an old-style external tool, an unsaved working
 360          * copy will be created from the arguments and returned.
 361          *
 362          * @param commandArgs
 363          *            the builder ICommand arguments
 364          * @param newName
 365          *            a new name for the config if the one in the command is invalid
 366          * @return a launch configuration, a launch configuration working copy, or
 367          *         <code>null</code> if not possible.
 368          */
 369 //      public static ILaunchConfiguration configFromBuildCommandArgs(
 370 //                      Map commandArgs) {
 371 //              String configHandle = (String) commandArgs.get(LAUNCH_CONFIG_HANDLE);
 372 //              if (configHandle == null) {
 373 //                      // Probably an old-style external tool. Try to migrate.
 374 //                      return ExternalToolMigration.configFromArgumentMap(commandArgs);
 375 //              }
 376 //              try {
 377 //                      return DebugPlugin.getDefault().getLaunchManager()
 378 //                                      .getLaunchConfiguration(configHandle);
 379 //              } catch (CoreException e) {
 380 //                      return null;
 381 //              }
 382 //      }
 383
 384         /**
 385          * Executes an external progam and saves the LaunchConfiguration under
 386          * external tools
 387          *
 388          * @param command
 389          *            external tools command name
 390          * @param executable
 391          *            executable path i.e.c:\apache\apache.exe
 392          * @param arguments
 393          *            arguments for this configuration
 394          * @param background
 395          *            run this configuration in background mode
 396          */
 397         public static void execute(String command, String executable,
 398                         String arguments, boolean background) {
 399                 execute(command, executable, null, arguments, background);
 400         }
 401
 402         public static void execute(String command, String executable,
 403                         String workingDirectory, String arguments, boolean background) {
 404                 ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
 405                 ILaunchConfigurationType type = manager
 406                                 .getLaunchConfigurationType(IExternalToolConstants.ID_PROGRAM_LAUNCH_CONFIGURATION_TYPE);
 407
 408                 ILaunchConfigurationWorkingCopy wc = null;
 409                 try {
 410                         wc = type.newInstance(null, command);
 411                 } catch (CoreException e) {
 412                         // some exception handling
 413                 }
 414                 wc.setAttribute(IExternalToolConstants.ATTR_LOCATION, executable);
 415                 if (workingDirectory != null) {
 416                         wc.setAttribute(IExternalToolConstants.ATTR_WORKING_DIRECTORY,
 417                                         workingDirectory);
 418                 }
 419                 if (arguments != null) {
 420                         wc.setAttribute(IExternalToolConstants.ATTR_TOOL_ARGUMENTS,
 421                                         arguments);
 422                 }
 423                 wc.setAttribute(IExternalToolConstants.ATTR_RUN_IN_BACKGROUND,
 424                                 background);
 425
 426                 // saving will add the configuration to the external tools
 427                 // configurations
 428                 ILaunchConfiguration config;
 429                 try {
 430                         config = wc.doSave();
 431                         config.launch(ILaunchManager.RUN_MODE, null);
 432                 } catch (CoreException e) {
 433                         alertDialog(executable);
 434                 }
 435
 436         }
 437
 438         /**
 439          * Shows an alert dialog with a warning message
 440          *
 441          * @param executable external tools command name
 442          */
 443         private static void alertDialog(String executable) {
 444                 IWorkbenchWindow window = PlatformUI.getWorkbench()
 445                                 .getActiveWorkbenchWindow();
 446                 MessageDialog.openWarning(window.getShell(), "Launch Error",
 447                                 "Could not execute external app" + executable);
 448         }
 449 }