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