001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     * 
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    
018    package org.apache.commons.launcher;
019    
020    import java.io.File;
021    import java.util.ArrayList;
022    import java.util.HashMap;
023    
024    /**
025     * A class that represents the holds the various argument types that are used
026     * in a Java command. In addition, it holds many of the flags that are used
027     * by the {@link LaunchTask} class when executing a JVM process.
028     *
029     * @author Patrick Luby
030     */
031    public class LaunchCommand {
032    
033        //------------------------------------------------------------------ Fields
034    
035        /**
036         * Cached appendOutput flag.
037         */
038        private boolean appendOutput = false;
039    
040        /**
041         * Cached classpath.
042         */
043        private String classpath = null;
044    
045        /**
046         * Cached debug flag.
047         */
048        private boolean debug = false;
049    
050        /**
051         * Cached displayMinimizedWindow flag.
052         */
053        private boolean displayMinimizedWindow = false;
054    
055        /**
056         * Cached disposeMinimizedWindow flag.
057         */
058        private boolean disposeMinimizedWindow = true;
059    
060        /**
061         * Cached failOnError flag.
062         */
063        private boolean failOnError = true;
064    
065        /**
066         * Cached main class name.
067         */
068        private String mainClassName = null;
069    
070        /**
071         * Cached minimizedWindowIcon.
072         */
073        private File minimizedWindowIcon = null;
074    
075        /**
076         * Cached minimizedWindowTitle.
077         */
078        private String minimizedWindowTitle = null;
079    
080        /**
081         * Cached output file.
082         */
083        private File outputFile = null;
084    
085        /**
086         * Cached print flag.
087         */
088        private boolean print = false;
089    
090        /**
091         * Cached requireTools flag.
092         */
093        private boolean requireTools = false;
094    
095        /**
096         * Cached redirect flag.
097         */
098        private boolean redirect = false;
099    
100        /**
101         * Cached arg elements
102         */
103        private ArrayList args = null;
104    
105        /**
106         * Cached jvmarg elements
107         */
108        private ArrayList jvmArgs = null;
109    
110        /**
111         * Cached sysproperty elements
112         */
113        private HashMap sysProperties = null;
114    
115        /**
116         * Cached useSystemIn flag.
117         */
118        private boolean useSystemIn = true;
119    
120        /**
121         * Cached waitForChild flag.
122         */
123        private boolean waitForChild = true;
124    
125        //----------------------------------------------------------------- Methods
126    
127        /**
128         * Get the class name.
129         *
130         * @return the class to execute <code>main(String[])</code>
131         */
132        public String getClassname() {
133    
134            return mainClassName;
135    
136        }
137    
138        /**
139         * Get the classpath.
140         *
141         * @return the classpath
142         */
143        public String getClasspath() {
144    
145            return classpath;
146    
147        }
148    
149        /**
150         * Get the debug flag.
151         *
152         * @return the debug flag
153         */
154        public boolean getDebug() {
155    
156            return debug;
157    
158        }
159    
160        /**
161         * Get the displayMinimizedWindow flag.
162         *
163         * @return the displayMinimizedWindow flag
164         */
165        public boolean getDisplayminimizedwindow() {
166    
167            return displayMinimizedWindow;
168    
169        }
170    
171        /**
172         * Get the disposeMinimizedWindow flag.
173         *
174         * @return the disposeMinimizedWindow flag
175         */
176        public boolean getDisposeminimizedwindow() {
177    
178            return disposeMinimizedWindow;
179    
180        }
181    
182        /**
183         * Get the failOnError flag.
184         *
185         * @return the failOnError flag
186         */
187        public boolean getFailonerror() {
188    
189            return failOnError;
190    
191        }
192    
193        /**
194         * Get the title for the minimized window that will be displayed in the
195         * Windows taskbar.
196         *
197         * @return the title to set for any minimized window that is displayed
198         *  in the Windows taskbar
199         */
200        public String getMinimizedwindowtitle() {
201    
202            return minimizedWindowTitle;
203    
204        }
205    
206        /**
207         * Get the icon file for the minimized window that will be displayed in the
208         * Windows taskbar.
209         *
210         * @return the icon file to use for any minimized window that is displayed
211         *  in the Windows taskbar
212         */
213        public File getMinimizedwindowicon() {
214    
215            return minimizedWindowIcon;
216    
217        }
218    
219        /**
220         * Get the file that the child JVM's System.out and System.err will be
221         * redirected to.
222         *
223         * @return the File to redirect System.out and System.err to
224         */
225        public File getOutput() {
226    
227            return outputFile;
228    
229        }
230    
231        /**
232         * Get the appendOutput flag.
233         *
234         * @return the appendOutput flag
235         */
236        public boolean getAppendoutput() {
237    
238            return appendOutput;
239    
240        }
241    
242        /**
243         * Get the redirect flag.
244         *
245         * @return the redirect flag
246         */
247        public boolean getRedirectoutput() {
248    
249            return redirect;
250    
251        }
252    
253        /**
254         * Get the list of nested arg elements.
255         *
256         * @return the list of {@link String} objects
257         */
258        public ArrayList getArgs() {
259    
260            return args;
261    
262        }
263    
264        /**
265         * Get the list of nested jvmarg elements.
266         *
267         * @return the list of {@link String} objects
268         */
269        public ArrayList getJvmargs() {
270    
271            return jvmArgs;
272    
273        }
274    
275        /**
276         * Get the print flag.
277         *
278         * @return the print flag
279         */
280        public boolean getPrint() {
281    
282            return print;
283    
284        }
285    
286        /**
287         * Get the requireTools flag.
288         *
289         * @return the requireTools flag
290         */
291        public boolean getRequiretools() {
292    
293            return requireTools;
294    
295        }
296    
297        /**
298         * Get the list of nested sysproperty elements.
299         *
300         * @return the {@link String} objects
301         */
302        public HashMap getSysproperties() {
303    
304            return sysProperties;
305    
306        }
307    
308        /**
309         * Get the useSystemIn flag.
310         *
311         * @return the useSystemIn flag
312         */
313        public boolean getUsesystemin() {
314    
315            return useSystemIn;
316    
317        }
318    
319        /**
320         * Get the waitForChild flag.
321         *
322         * @return the waitForChild flag
323         */
324        public boolean getWaitforchild() {
325    
326            return waitForChild;
327    
328        }
329    
330        /**
331         * Set the print flag.
332         *
333         * @param print the print flag
334         */
335        public void setPrint(boolean print) {
336    
337            this.print = print;
338    
339        }
340    
341        /**
342         * Set the requireTools flag.
343         *
344         * @param requireTools the requireTools flag
345         */
346        public void setRequiretools(boolean requireTools) {
347    
348            this.requireTools = requireTools;
349    
350        }
351    
352        /**
353         * Set the useSystemIn flag. Setting this flag to false will cause this
354         * task to not read System.in. This will cause the child JVM to never
355         * receive any bytes when it reads System.in. Setting this flag to false
356         * is useful in some Unix environments where processes cannot be put in
357         * the background when they read System.in.
358         *
359         * @param useSystemIn the useSystemIn flag
360         */
361        public void setUsesystemin(boolean useSystemIn) {
362    
363            this.useSystemIn = useSystemIn;
364    
365        }
366    
367        /**
368         * Set the waitForChild flag. Setting this flag to true will cause this
369         * task to wait for the child JVM to finish executing before the task
370         * completes. Setting this flag to false will cause this task to complete
371         * immediately after it starts the execution of the child JVM. Setting it
372         * false emulates the "&" background operator in most Unix shells and is
373         * most of set to false when launching server or GUI applications.
374         *
375         * @param waitForChild the waitForChild flag
376         */
377        public void setWaitforchild(boolean waitForChild) {
378    
379            this.waitForChild = waitForChild;
380    
381        }
382    
383        /**
384         * Set the class name.
385         *
386         * @param mainClassName the class to execute <code>main(String[])</code>
387         */
388        public void setClassname(String mainClassName) {
389    
390            this.mainClassName = mainClassName;
391    
392        }
393    
394        /**
395         * Set the classpath.
396         *
397         * @param classpath the classpath
398         */
399        public void setClasspath(String classpath) {
400    
401            this.classpath = classpath;
402    
403        }
404    
405        /**
406         * Set the debug flag.
407         *
408         * @param debug the debug flag 
409         */
410        public void setDebug(boolean debug) {
411    
412            this.debug = debug;
413    
414        }
415    
416        /**
417         * Set the displayMinimizedWindow flag. Note that this flag has no effect
418         * on non-Windows platforms. On Windows platform, setting this flag to true
419         * will cause a minimized window to be displayed in the Windows task bar
420         * while the child process is executing. This flag is usually set to true
421         * for server applications that also have their "waitForChild" attribute
422         * set to false via the {@link #setWaitforchild(boolean)} method.
423         *
424         * @param displayMinimizedWindow true if a minimized window should be
425         *  displayed in the Windows task bar while the child process is executing 
426         */
427        public void setDisplayminimizedwindow(boolean displayMinimizedWindow) {
428    
429            this.displayMinimizedWindow = displayMinimizedWindow;
430    
431        }
432    
433        /**
434         * Set the disposeMinimizedWindow flag. Note that this flag has no effect
435         * on non-Windows platforms. On Windows platform, setting this flag to true
436         * will cause any minimized window that is display by setting the
437         * "displayMinimizedWindow" attribute to true via the
438         * {@link #setDisplayminimizedwindow(boolean)} to be automatically
439         * disposed of when the child JVM's <code>main(String[])</code> returns.
440         * This flag is normally used for applications that don't explicitly call
441         * {@link System#exit(int)}. If an application does not explicitly call
442         * {@link System#exit(int)}, an minimized windows need to be disposed of
443         * for the child JVM to exit.
444         *
445         * @param disposeMinimizedWindow true if a minimized window in the Windows
446         *  taskbar should be automatically disposed of after the child JVM's
447         *  <code>main(String[])</code> returns
448         */
449        public void setDisposeminimizedwindow(boolean disposeMinimizedWindow) {
450    
451            this.disposeMinimizedWindow = disposeMinimizedWindow;
452    
453        }
454    
455        /**
456         * Set the failOnError flag.
457         *
458         * @param failOnError the failOnError flag 
459         */
460        public void setFailonerror(boolean failOnError) {
461    
462            this.failOnError = failOnError;
463    
464        }
465    
466        /**
467         * Set the title for the minimized window that will be displayed in the
468         * Windows taskbar. Note that this property has no effect on non-Windows
469         * platforms.
470         *
471         * @param minimizedWindowTitle the title to set for any minimized window
472         *  that is displayed in the Windows taskbar
473         */
474        public void setMinimizedwindowtitle(String minimizedWindowTitle) {
475    
476            this.minimizedWindowTitle = minimizedWindowTitle;
477    
478        }
479    
480        /**
481         * Set the icon file for the minimized window that will be displayed in the
482         * Windows taskbar. Note that this property has no effect on non-Windows
483         * platforms.
484         *
485         * @param minimizedWindowIcon the icon file to use for any minimized window
486         *  that is displayed in the Windows taskbar
487         */
488        public void setMinimizedwindowicon(File minimizedWindowIcon) {
489    
490            this.minimizedWindowIcon = minimizedWindowIcon;
491    
492        }
493    
494        /**
495         * Set the file that the child JVM's System.out and System.err will be
496         * redirected to. Output will only be redirected if the redirect flag
497         * is set to true via the {@link #setRedirectoutput(boolean)} method.
498         *
499         * @param outputFile a File to redirect System.out and System.err to
500         */
501        public void setOutput(File outputFile) {
502    
503            this.outputFile = outputFile;
504    
505        }
506    
507        /**
508         * Set the appendOutput flag. Setting this flag to true will cause the child
509         * JVM to append System.out and System.err to the file specified by the
510         * {@link #setOutput(File)} method. Setting this flag to false will cause
511         * the child to overwrite the file.
512         *
513         * @param appendOutput true if output should be appended to the output file
514         */
515        public void setAppendoutput(boolean appendOutput) {
516    
517            this.appendOutput = appendOutput;
518    
519        }
520    
521        /**
522         * Set the list of nested arg elements.
523         *
524         * @param args a list of {@link String} objects
525         */
526        public void setArgs(ArrayList args) {
527    
528            this.args = args;
529    
530        }
531    
532        /**
533         * Set the list of nested jvmarg elements.
534         *
535         * @param jvmArgs a list of {@link String} objects
536         */
537        public void setJvmargs(ArrayList jvmArgs) {
538    
539            this.jvmArgs = jvmArgs;
540    
541        }
542    
543        /**
544         * Set the list of nested sysproperty elements.
545         *
546         * @param sysProperties a map of {@link String} objects
547         */
548        public void setSysproperties(HashMap sysProperties) {
549    
550            this.sysProperties = sysProperties;
551    
552        }
553    
554        /**
555         * Set the redirect flag. Setting this flag to true will cause the child
556         * JVM's System.out and System.err to be redirected to file set using the
557         * {@link #setOutput(File)} method. Setting this flag to false will
558         * cause no redirection.
559         *
560         * @param redirect true if System.out and System.err should be redirected
561         */
562        public void setRedirectoutput(boolean redirect) {
563    
564            this.redirect = redirect;
565    
566        }
567    
568    }