001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2008 Sun Microsystems, Inc.
026 */
027
028 package org.opends.server.tools;
029
030 import static org.opends.messages.ToolMessages.*;
031 import static org.opends.server.util.ServerConstants.EOL;
032
033 import java.io.BufferedReader;
034 import java.io.BufferedWriter;
035 import java.io.File;
036 import java.io.FileNotFoundException;
037 import java.io.FileReader;
038 import java.io.FileWriter;
039 import java.io.IOException;
040 import java.io.InputStream;
041 import java.io.OutputStream;
042 import java.io.PrintStream;
043 import java.util.Enumeration;
044 import java.util.Properties;
045
046 import org.opends.messages.Message;
047 import org.opends.messages.ToolMessages;
048 import org.opends.quicksetup.Constants;
049 import org.opends.quicksetup.util.Utils;
050 import org.opends.server.types.NullOutputStream;
051 import org.opends.server.util.args.ArgumentException;
052 import org.opends.server.util.cli.ConsoleApplication;
053
054 /**
055 * This class is used to update the scripts that are used to launch the command
056 * lines. We read the contents of a given properties file and we update the
057 * scripts setting the arguments and JVM to be used by the different scripts.
058 *
059 */
060 public class JavaPropertiesTool extends ConsoleApplication
061 {
062 // The argument parser
063 private JavaPropertiesToolArgumentParser argParser;
064
065 /**
066 * The enumeration containing the different return codes that the command-line
067 * can have.
068 *
069 */
070 public enum ErrorReturnCode
071 {
072 /**
073 * Successful setup.
074 */
075 SUCCESSFUL(0),
076 /**
077 * We did no have an error but the setup was not executed (displayed version
078 * or usage).
079 */
080 SUCCESSFUL_NOP(0),
081 /**
082 * Unexpected error (potential bug).
083 */
084 ERROR_UNEXPECTED(1),
085 /**
086 * Cannot parse arguments or data provided by user is not valid.
087 */
088 ERROR_USER_DATA(2),
089 /**
090 * Error writing to destination file.
091 */
092 ERROR_WRITING_FILE(3);
093
094 private int returnCode;
095 private ErrorReturnCode(int returnCode)
096 {
097 this.returnCode = returnCode;
098 }
099
100 /**
101 * Get the corresponding return code value.
102 *
103 * @return The corresponding return code value.
104 */
105 public int getReturnCode()
106 {
107 return returnCode;
108 }
109 };
110
111 final private static String DEFAULT_JAVA_HOME_PROP_NAME = "default.java-home";
112 final private static String DEFAULT_JAVA_ARGS_PROP_NAME = "default.java-args";
113 final private static String OVERWRITE_ENV_JAVA_HOME_PROP_NAME =
114 "overwrite-env-java-home";
115 final private static String OVERWRITE_ENV_JAVA_ARGS_PROP_NAME =
116 "overwrite-env-java-args";
117
118 /**
119 * Constructor for the JavaPropertiesTool object.
120 *
121 * @param out the print stream to use for standard output.
122 * @param err the print stream to use for standard error.
123 * @param in the input stream to use for standard input.
124 */
125 public JavaPropertiesTool(PrintStream out, PrintStream err, InputStream in)
126 {
127 super(in, out, err);
128 }
129
130 /**
131 * The main method for the java properties tool.
132 *
133 * @param args the command-line arguments provided to this program.
134 */
135
136 public static void main(String[] args)
137 {
138 int retCode = mainCLI(args, System.out, System.err, System.in);
139
140 System.exit(retCode);
141 }
142
143 /**
144 * Parses the provided command-line arguments and uses that information to
145 * run the java properties tool.
146 *
147 * @param args the command-line arguments provided to this program.
148 *
149 * @return The error code.
150 */
151
152 public static int mainCLI(String[] args)
153 {
154 return mainCLI(args, System.out, System.err, System.in);
155 }
156
157 /**
158 * Parses the provided command-line arguments and uses that information to
159 * run the java properties tool.
160 *
161 * @param args The command-line arguments provided to this
162 * program.
163 * @param outStream The output stream to use for standard output, or
164 * <CODE>null</CODE> if standard output is not
165 * needed.
166 * @param errStream The output stream to use for standard error, or
167 * <CODE>null</CODE> if standard error is not
168 * needed.
169 * @param inStream The input stream to use for standard input.
170 * @return The error code.
171 */
172
173 public static int mainCLI(String[] args, OutputStream outStream,
174 OutputStream errStream, InputStream inStream)
175 {
176 PrintStream out;
177 if (outStream == null)
178 {
179 out = NullOutputStream.printStream();
180 }
181 else
182 {
183 out = new PrintStream(outStream);
184 }
185
186 System.setProperty(Constants.CLI_JAVA_PROPERTY, "true");
187
188 PrintStream err;
189 if (errStream == null)
190 {
191 err = NullOutputStream.printStream();
192 }
193 else
194 {
195 err = new PrintStream(errStream);
196 }
197
198 JavaPropertiesTool tool = new JavaPropertiesTool(out, err, inStream);
199
200 return tool.execute(args);
201 }
202
203 /**
204 * Parses the provided command-line arguments and uses that information to
205 * run the java properties tool.
206 *
207 * @param args the command-line arguments provided to this program.
208 *
209 * @return the return code (SUCCESSFUL, USER_DATA_ERROR or BUG).
210 */
211 public int execute(String[] args)
212 {
213 argParser = new JavaPropertiesToolArgumentParser(
214 JavaPropertiesTool.class.getName());
215 try
216 {
217 argParser.initializeArguments();
218 }
219 catch (ArgumentException ae)
220 {
221 Message message =
222 ToolMessages.ERR_CANNOT_INITIALIZE_ARGS.get(ae.getMessage());
223 println(message);
224 return ErrorReturnCode.ERROR_UNEXPECTED.getReturnCode();
225 }
226
227 // Validate user provided data
228 try
229 {
230 argParser.parseArguments(args);
231 }
232 catch (ArgumentException ae)
233 {
234 Message message = ERR_ERROR_PARSING_ARGS.get(ae.getMessage());
235 println(message);
236 println();
237 println(Message.raw(argParser.getUsage()));
238
239 return ErrorReturnCode.ERROR_USER_DATA.getReturnCode();
240 }
241
242 if (argParser.usageOrVersionDisplayed())
243 {
244 return ErrorReturnCode.SUCCESSFUL_NOP.getReturnCode();
245 }
246
247 Properties properties = new Properties();
248 BufferedReader reader = null;
249 String propertiesFile = argParser.propertiesFileArg.getValue();
250 try
251 {
252 reader = new BufferedReader(new FileReader(propertiesFile));
253 }
254 catch (FileNotFoundException fnfe)
255 {
256 println(ERR_JAVAPROPERTIES_WITH_PROPERTIES_FILE.get(propertiesFile));
257 return ErrorReturnCode.ERROR_USER_DATA.getReturnCode();
258 }
259 try
260 {
261 String line;
262 // Parse the file manually since '\' in windows paths can generate issues.
263 while ((line = reader.readLine()) != null)
264 {
265 line = line.trim();
266 if (!line.startsWith("#"))
267 {
268 int index = line.indexOf('=');
269 if (index != -1)
270 {
271 String key = line.substring(0, index);
272 if (key.indexOf(' ') == -1)
273 {
274 if (index < line.length())
275 {
276 String value = line.substring(index+1);
277 properties.setProperty(key, value);
278 }
279 else
280 {
281 properties.setProperty(key, "");
282 }
283 }
284 }
285 }
286 }
287 }
288 catch (IOException ioe)
289 {
290 println(ERR_JAVAPROPERTIES_WITH_PROPERTIES_FILE.get(propertiesFile));
291 return ErrorReturnCode.ERROR_USER_DATA.getReturnCode();
292 }
293
294 String destinationFile = argParser.destinationFileArg.getValue();
295
296 BufferedWriter writer = null;
297 try
298 {
299 writer = new BufferedWriter(new FileWriter(destinationFile));
300 }
301 catch (IOException ioe)
302 {
303 println(ERR_JAVAPROPERTIES_WITH_DESTINATION_FILE.get(destinationFile));
304 return ErrorReturnCode.ERROR_USER_DATA.getReturnCode();
305 }
306
307 Enumeration propertyNames = properties.propertyNames();
308
309 boolean overwriteEnvJavaHome = true;
310 boolean overwriteEnvJavaArgs = true;
311 String defaultJavaHome = null;
312 String defaultJavaArgs = null;
313
314 while (propertyNames.hasMoreElements())
315 {
316 String name = propertyNames.nextElement().toString();
317 String value = properties.getProperty(name);
318
319 if (value != null)
320 {
321 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME))
322 {
323 defaultJavaHome = value;
324 }
325 else if (name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME))
326 {
327 defaultJavaArgs = value;
328 }
329 else if (name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME))
330 {
331 if ("false".equalsIgnoreCase(value))
332 {
333 overwriteEnvJavaHome = false;
334 }
335 }
336 else if (name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
337 {
338 if ("false".equalsIgnoreCase(value))
339 {
340 overwriteEnvJavaArgs = false;
341 }
342 }
343 }
344 }
345
346 try
347 {
348 String value;
349 if (Utils.isWindows())
350 {
351 value = getWindowsContents(overwriteEnvJavaHome, overwriteEnvJavaArgs,
352 defaultJavaHome, defaultJavaArgs, properties);
353 }
354 else
355 {
356 value = getUnixContents(overwriteEnvJavaHome, overwriteEnvJavaArgs,
357 defaultJavaHome, defaultJavaArgs, properties);
358 }
359
360 writer.write(value);
361 writer.newLine();
362 writer.close();
363 }
364 catch (IOException ioe)
365 {
366 println(Utils.getThrowableMsg(
367 ERR_JAVAPROPERTIES_WRITING_DESTINATION_FILE.get(destinationFile),
368 ioe));
369 return ErrorReturnCode.ERROR_WRITING_FILE.getReturnCode();
370 }
371
372 // Add some information if we are not in quiet mode about
373 // what is going to happen.
374 File f1 = new File(argParser.destinationFileArg.getValue());
375 File f2 = new File(argParser.destinationFileArg.getDefaultValue());
376 if (f1.equals(f2))
377 {
378 printProgress(INFO_JAVAPROPERTIES_SUCCESSFUL.get(
379 argParser.propertiesFileArg.getValue()));
380 }
381 else
382 {
383 printProgress(INFO_JAVAPROPERTIES_SUCCESSFUL_NON_DEFAULT.get(
384 argParser.destinationFileArg.getValue(),
385 argParser.propertiesFileArg.getValue(),
386 argParser.destinationFileArg.getDefaultValue()));
387 }
388 printlnProgress();
389
390
391 return ErrorReturnCode.SUCCESSFUL.getReturnCode();
392 }
393
394
395 /**
396 * {@inheritDoc}
397 */
398 public boolean isQuiet()
399 {
400 return argParser.quietArg.isPresent();
401 }
402
403 /**
404 * {@inheritDoc}
405 */
406 public boolean isInteractive()
407 {
408 return false;
409 }
410
411 /**
412 * {@inheritDoc}
413 */
414 @Override
415 public boolean isMenuDrivenMode() {
416 return true;
417 }
418
419 /**
420 * {@inheritDoc}
421 */
422 public boolean isScriptFriendly() {
423 return false;
424 }
425
426 /**
427 * {@inheritDoc}
428 */
429 public boolean isAdvancedMode() {
430 return false;
431 }
432
433
434 /**
435 * {@inheritDoc}
436 */
437 public boolean isVerbose() {
438 return true;
439 }
440
441 private String getUnixContents(boolean overwriteJavaHome,
442 boolean overwriteJavaArgs, String defaultJavaHome, String defaultJavaArgs,
443 Properties properties)
444 {
445 StringBuilder buf = new StringBuilder();
446 buf.append("#!/bin/sh"+EOL+EOL);
447
448 if (!overwriteJavaHome)
449 {
450 buf.append(
451 "# See if the environment variables for java home are set"+EOL+
452 "# in the path and try to figure it out."+EOL+
453 "if test ! -f \"${OPENDS_JAVA_BIN}\""+EOL+
454 "then"+EOL+
455 " if test ! -d \"${OPENDS_JAVA_HOME}\""+EOL);
456 }
457
458 boolean propertiesAdded = false;
459
460 Enumeration propertyNames = properties.propertyNames();
461 int nIfs = 0;
462 while (propertyNames.hasMoreElements())
463 {
464 String name = propertyNames.nextElement().toString();
465 String value = properties.getProperty(name);
466
467 if (value != null)
468 {
469 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME) ||
470 name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME) ||
471 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME) ||
472 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
473 {
474 // Already handled
475 }
476 else if (name.endsWith(".java-home"))
477 {
478 propertiesAdded = true;
479 String s;
480 if (nIfs > 0)
481 {
482 if (!overwriteJavaHome)
483 {
484 s = " ";
485 }
486 else
487 {
488 s = "";
489 }
490 buf.append(
491 s+"elif test \"${SCRIPT_NAME}.java-home\" = \""+name+"\""+EOL);
492 }
493 else if (!overwriteJavaHome)
494 {
495 buf.append(
496 " then"+EOL+
497 " if test \"${SCRIPT_NAME}.java-home\" = \""+name+"\""+EOL);
498 s = " ";
499 }
500 else
501 {
502 buf.append(
503 "if test \"${SCRIPT_NAME}.java-home\" = \""+name+"\""+EOL);
504 s = "";
505 }
506
507 buf.append(
508 s+"then"+EOL+
509 s+" TEMP=\""+value+"/bin/java\""+EOL+
510 s+" if test -f ${TEMP}"+EOL+
511 s+" then"+EOL+
512 s+" OPENDS_JAVA_BIN=\""+value+"/bin/java\""+EOL+
513 s+" export OPENDS_JAVA_BIN"+EOL+
514 s+" fi"+EOL);
515 nIfs++;
516 }
517 }
518 }
519 if (defaultJavaHome != null)
520 {
521 if (propertiesAdded)
522 {
523 String s;
524 if (!overwriteJavaHome)
525 {
526 s = " ";
527 }
528 else
529 {
530 s = "";
531 }
532 buf.append(
533 s+"else"+EOL+
534 s+" OPENDS_JAVA_BIN=\""+defaultJavaHome+"/bin/java\""+EOL+
535 s+" export OPENDS_JAVA_BIN"+EOL);
536 }
537 else
538 {
539 if (!overwriteJavaHome)
540 {
541 buf.append(
542 " then"+EOL+
543 " TEMP=\""+defaultJavaHome+"/bin/java\""+EOL+
544 " if test -f ${TEMP}"+EOL+
545 " then"+EOL+
546 " OPENDS_JAVA_BIN=${TEMP}"+EOL+
547 " export OPENDS_JAVA_BIN"+EOL+
548 " fi"+EOL);
549 }
550 else
551 {
552 buf.append(
553 "OPENDS_JAVA_BIN=\""+defaultJavaHome+"/bin/java\""+EOL+
554 "export OPENDS_JAVA_BIN"+EOL);
555 }
556 }
557 propertiesAdded = true;
558 }
559
560 if (nIfs > 0)
561 {
562 String s;
563 if (!overwriteJavaHome)
564 {
565 s = " ";
566 }
567 else
568 {
569 s = "";
570 }
571 buf.append(
572 s+"fi"+EOL);
573 }
574
575
576 if (!overwriteJavaHome)
577 {
578 if (!propertiesAdded)
579 {
580 // No properties added: this is required not to break the script
581 buf.append(
582 " then"+EOL+
583 " OPENDS_JAVA_BIN=${OPENDS_JAVA_BIN}"+EOL);
584 }
585 buf.append(
586 " else"+EOL+
587 " OPENDS_JAVA_BIN=${OPENDS_JAVA_HOME}/bin/java"+EOL+
588 " export OPENDS_JAVA_BIN"+EOL+
589 " fi"+EOL+
590 "fi"+EOL+EOL);
591 }
592 else if (defaultJavaHome == null)
593 {
594 buf.append(
595 EOL+
596 "if test ! -f \"${OPENDS_JAVA_BIN}\""+EOL+
597 "then"+EOL+
598 " if test ! -d \"${OPENDS_JAVA_HOME}\""+EOL+
599 " then"+EOL+
600 " if test ! -f \"${JAVA_BIN}\""+EOL+
601 " then"+EOL+
602 " if test ! -d \"${JAVA_HOME}\""+EOL+
603 " then"+EOL+
604 " OPENDS_JAVA_BIN=`which java 2> /dev/null`"+EOL+
605 " if test ${?} -eq 0"+EOL+
606 " then"+EOL+
607 " export OPENDS_JAVA_BIN"+EOL+
608 " else"+EOL+
609 " echo \"You must specify the path to a valid Java 5.0 or "+
610 "higher version in the\""+EOL+
611 " echo \"properties file and then run the dsjavaproperties "+
612 "tool. \""+EOL+
613 " echo \"The procedure to follow is:\""+EOL+
614 " echo \"You must specify the path to a valid Java 5.0 or "+
615 "higher version. The \""+EOL+
616 " echo \"procedure to follow is:\""+EOL+
617 " echo \"1. Delete the file "+
618 "${INSTANCE_ROOT}/lib/set-java-home\""+EOL+
619 " echo \"2. Set the environment variable OPENDS_JAVA_HOME "+
620 "to the root of a valid \""+EOL+
621 " echo \"Java 5.0 installation.\""+EOL+
622 " echo \"If you want to have specificjava settings for "+
623 "each command line you must\""+EOL+
624 " echo \"follow the steps 3 and 4\""+EOL+
625 " echo \"3. Edit the properties file specifying the java "+
626 "binary and the java arguments\""+EOL+
627 " echo \"for each command line. The java properties file "+
628 "is located in:\""+EOL+
629 " echo \"${INSTANCE_ROOT}/config/java.properties.\""+EOL+
630 " echo \"4. Run the command-line "+
631 "${INSTANCE_ROOT}/bin/dsjavaproperties\""+EOL+
632 " exit 1"+EOL+
633 " fi"+EOL+
634 " else"+EOL+
635 " OPENDS_JAVA_BIN=\"${JAVA_HOME}/bin/java\""+EOL+
636 " export OPENDS_JAVA_BIN"+EOL+
637 " fi"+EOL+
638 " else"+EOL+
639 " OPENDS_JAVA_BIN=\"${JAVA_BIN}\""+EOL+
640 " export OPENDS_JAVA_BIN"+EOL+
641 " fi"+EOL+
642 " else"+EOL+
643 " OPENDS_JAVA_BIN=\"${OPENDS_JAVA_HOME}/bin/java\""+EOL+
644 " export OPENDS_JAVA_BIN"+EOL+
645 " fi"+EOL+
646 "fi"+EOL+EOL);
647 }
648
649
650 if (!overwriteJavaArgs)
651 {
652 buf.append(
653 EOL+
654 "# See if the environment variables for arguments are set."+EOL+
655 "if test -z \"${OPENDS_JAVA_ARGS}\""+EOL);
656 }
657
658 propertiesAdded = false;
659
660 propertyNames = properties.propertyNames();
661 nIfs = 0;
662 while (propertyNames.hasMoreElements())
663 {
664 String name = propertyNames.nextElement().toString();
665 String value = properties.getProperty(name);
666
667 String s = overwriteJavaArgs? "":" ";
668
669 if (value != null)
670 {
671 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME) ||
672 name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME) ||
673 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME) ||
674 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
675 {
676 // Already handled
677 }
678 else if (name.endsWith(".java-args"))
679 {
680 propertiesAdded = true;
681 if (nIfs > 0)
682 {
683 buf.append(
684 s+"elif test \"${SCRIPT_NAME}.java-args\" = \""+name+"\""+EOL);
685 }
686 else if (!overwriteJavaArgs)
687 {
688 buf.append(
689 "then"+EOL+
690 " if test \"${SCRIPT_NAME}.java-args\" = \""+name+"\""+EOL);
691 }
692 else
693 {
694 buf.append(
695 "if test \"${SCRIPT_NAME}.java-args\" = \""+name+"\""+EOL);
696 }
697 buf.append(
698 s+"then"+EOL+
699 s+" OPENDS_JAVA_ARGS=\""+value+"\""+EOL+
700 s+" export OPENDS_JAVA_ARGS"+EOL);
701 nIfs++;
702 }
703 }
704 }
705 if (defaultJavaArgs != null)
706 {
707 String s = overwriteJavaArgs? "":" ";
708 if (propertiesAdded)
709 {
710 buf.append(
711 s+"else"+EOL+
712 s+" OPENDS_JAVA_ARGS=\""+defaultJavaArgs+"\""+EOL+
713 s+" export OPENDS_JAVA_ARGS"+EOL);
714 }
715 else
716 {
717 if (!overwriteJavaArgs)
718 {
719 buf.append(
720 " then"+EOL+
721 " OPENDS_JAVA_ARGS=\""+defaultJavaArgs+"\""+EOL+
722 " export OPENDS_JAVA_ARGS"+EOL);
723 }
724 else
725 {
726 buf.append(
727 EOL+
728 "OPENDS_JAVA_ARGS=\""+defaultJavaArgs+"\""+EOL+
729 "export OPENDS_JAVA_ARGS"+EOL);
730 }
731 }
732 propertiesAdded = true;
733 }
734 if (nIfs > 0)
735 {
736 String s = overwriteJavaArgs? "":" ";
737 buf.append(s+"fi"+EOL);
738 }
739
740 if (!overwriteJavaArgs)
741 {
742 if (!propertiesAdded)
743 {
744 // No properties added: this is required not to break the script
745 buf.append(
746 " then"+EOL+
747 " OPENDS_JAVA_ARGS=${OPENDS_JAVA_ARGS}"+EOL);
748 }
749 buf.append(
750 "fi"+EOL);
751 }
752
753 return buf.toString();
754 }
755
756 private String getWindowsContents(boolean overwriteJavaHome,
757 boolean overwriteJavaArgs, String defaultJavaHome, String defaultJavaArgs,
758 Properties properties)
759 {
760 StringBuilder buf = new StringBuilder();
761
762 String javaHomeLabel1;
763 String javaArgsLabel1;
764 String javaHomeLabel2;
765 String javaArgsLabel2;
766
767 final String CHECK_ENV_JAVA_HOME = "checkEnvJavaHome";
768 final String CHECK_ENV_JAVA_ARGS = "checkEnvJavaArgs";
769 final String CHECK_JAVA_HOME = "checkJavaHome";
770 final String CHECK_JAVA_ARGS = "checkJavaArgs";
771 final String CHECK_DEFAULT_JAVA_HOME = "checkDefaultJavaHome";
772 final String CHECK_DEFAULT_JAVA_ARGS = "checkDefaultJavaArgs";
773
774 if (!overwriteJavaHome)
775 {
776 javaHomeLabel1 = CHECK_ENV_JAVA_HOME;
777 javaHomeLabel2 = CHECK_JAVA_HOME;
778 }
779 else
780 {
781 javaHomeLabel1 = CHECK_JAVA_HOME;
782 javaHomeLabel2 = CHECK_ENV_JAVA_HOME;
783 }
784
785 if (!overwriteJavaArgs)
786 {
787 javaArgsLabel1 = CHECK_ENV_JAVA_ARGS;
788 javaArgsLabel2 = CHECK_JAVA_ARGS;
789 }
790 else
791 {
792 javaArgsLabel1 = CHECK_JAVA_ARGS;
793 javaArgsLabel2 = CHECK_ENV_JAVA_ARGS;
794 }
795
796 buf.append("goto "+javaHomeLabel1+EOL+EOL);
797
798 buf.append(
799 ":"+CHECK_ENV_JAVA_HOME+EOL+
800 "if \"%OPENDS_JAVA_BIN%\" == \"\" goto checkOpendsJavaHome"+EOL+
801 "if not exist \"%OPENDS_JAVA_BIN%\" goto checkOpendsJavaHome"+EOL+
802 "goto "+javaArgsLabel1+EOL+EOL+
803 ":checkOpendsJavaHome"+EOL);
804
805 if (javaHomeLabel1 == CHECK_ENV_JAVA_HOME)
806 {
807 buf.append(
808 "if \"%OPENDS_JAVA_HOME%\" == \"\" goto "+javaHomeLabel2+EOL+
809 "set TEMP=%OPENDS_JAVA_HOME%\\bin\\java.exe"+EOL+
810 "if not exist \"%TEMP%\" goto "+javaHomeLabel2+EOL+
811 "set OPENDS_JAVA_BIN=%TEMP%"+EOL+
812 "goto "+javaArgsLabel1+EOL+EOL
813 );
814 }
815 else
816 {
817 buf.append(
818 "if \"%OPENDS_JAVA_HOME%\" == \"\" goto "+javaArgsLabel1+EOL+
819 "set TEMP=%OPENDS_JAVA_HOME%\\bin\\java.exe"+EOL+
820 "if not exist \"%TEMP%\" goto "+javaArgsLabel1+EOL+
821 "set OPENDS_JAVA_BIN=%TEMP%"+EOL+
822 "goto "+javaArgsLabel1+EOL+EOL
823 );
824 }
825
826 if (defaultJavaHome != null)
827 {
828 if (javaHomeLabel1 == CHECK_ENV_JAVA_HOME)
829 {
830 buf.append(
831 ":"+CHECK_DEFAULT_JAVA_HOME+EOL+
832 "set TEMP="+defaultJavaHome+"\\bin\\java.exe"+EOL+
833 "if not exist \"%TEMP%\" goto "+javaArgsLabel1+EOL+
834 "set OPENDS_JAVA_BIN=%TEMP%"+EOL+
835 "goto "+javaArgsLabel1+EOL+EOL
836 );
837 }
838 else
839 {
840 buf.append(
841 ":"+CHECK_DEFAULT_JAVA_HOME+EOL+
842 "set TEMP="+defaultJavaHome+"\\bin\\java.exe"+EOL+
843 "if not exist \"%TEMP%\" goto "+CHECK_ENV_JAVA_HOME+EOL+
844 "set OPENDS_JAVA_BIN=%TEMP%"+EOL+
845 "goto "+javaArgsLabel1+EOL+EOL
846 );
847 }
848 }
849
850 buf.append(
851 ":"+CHECK_JAVA_HOME+EOL);
852 Enumeration propertyNames = properties.propertyNames();
853 while (propertyNames.hasMoreElements())
854 {
855 String name = propertyNames.nextElement().toString();
856 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME) ||
857 name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME) ||
858 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME) ||
859 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
860 {
861 // Already handled
862 }
863 else if (name.endsWith(".java-home"))
864 {
865 String scriptName = name.substring(0,
866 name.length() - ".java-home".length());
867 buf.append(
868 "if \"%SCRIPT_NAME%.java-home\" == \""+name+"\" goto check"+
869 scriptName+"JavaHome"+EOL);
870 }
871 }
872 if (defaultJavaHome != null)
873 {
874 buf.append("goto "+CHECK_DEFAULT_JAVA_HOME+EOL+EOL);
875 }
876 else if (javaHomeLabel1 != CHECK_ENV_JAVA_HOME)
877 {
878 buf.append("goto "+CHECK_ENV_JAVA_HOME+EOL+EOL);
879 }
880 else
881 {
882 buf.append("goto "+javaArgsLabel1+EOL+EOL);
883 }
884
885 propertyNames = properties.propertyNames();
886 while (propertyNames.hasMoreElements())
887 {
888 String name = propertyNames.nextElement().toString();
889 String value = properties.getProperty(name);
890 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME) ||
891 name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME) ||
892 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME) ||
893 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
894 {
895 // Already handled
896 }
897 else if (name.endsWith(".java-home"))
898 {
899 String scriptName = name.substring(0,
900 name.length() - ".java-home".length());
901 buf.append(
902 ":check"+scriptName+"JavaHome"+EOL+
903 "set TEMP="+value+"\\bin\\java.exe"+EOL);
904 if (defaultJavaHome != null)
905 {
906 buf.append(
907 "if not exist \"%TEMP%\" goto "+CHECK_DEFAULT_JAVA_HOME+EOL);
908 }
909 else if (javaHomeLabel1 != CHECK_ENV_JAVA_HOME)
910 {
911 buf.append(
912 "if not exist \"%TEMP%\" goto "+CHECK_ENV_JAVA_HOME+EOL);
913 }
914 buf.append(
915 "set OPENDS_JAVA_BIN=%TEMP%"+EOL+
916 "goto "+javaArgsLabel1+EOL+EOL);
917 }
918 }
919
920 buf.append(
921 ":"+CHECK_ENV_JAVA_ARGS+EOL);
922 if (javaArgsLabel1 == CHECK_ENV_JAVA_ARGS)
923 {
924 buf.append(
925 "if \"%OPENDS_JAVA_ARGS%\" == \"\" goto "+javaArgsLabel2+EOL+
926 "goto end"+EOL+EOL);
927 }
928 else
929 {
930 buf.append(
931 "goto end"+EOL+EOL);
932 }
933
934 if (defaultJavaArgs != null)
935 {
936 buf.append(
937 ":"+CHECK_DEFAULT_JAVA_ARGS+EOL+
938 "set OPENDS_JAVA_ARGS="+defaultJavaArgs+EOL+
939 "goto end"+EOL+EOL);
940 }
941
942 buf.append(
943 ":"+CHECK_JAVA_ARGS+EOL);
944 propertyNames = properties.propertyNames();
945 while (propertyNames.hasMoreElements())
946 {
947 String name = propertyNames.nextElement().toString();
948 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME) ||
949 name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME) ||
950 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME) ||
951 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
952 {
953 // Already handled
954 }
955 else if (name.endsWith(".java-args"))
956 {
957 String scriptName = name.substring(0,
958 name.length() - ".java-args".length());
959 buf.append(
960 "if \"%SCRIPT_NAME%.java-args\" == \""+name+"\" goto check"+
961 scriptName+"JavaArgs"+EOL);
962 }
963 }
964 if (defaultJavaArgs != null)
965 {
966 buf.append("goto "+CHECK_DEFAULT_JAVA_ARGS+EOL+EOL);
967 }
968 else if (javaArgsLabel1 != CHECK_ENV_JAVA_ARGS)
969 {
970 buf.append("goto "+CHECK_ENV_JAVA_ARGS+EOL+EOL);
971 }
972 else
973 {
974 buf.append("goto end"+EOL+EOL);
975 }
976
977 propertyNames = properties.propertyNames();
978 while (propertyNames.hasMoreElements())
979 {
980 String name = propertyNames.nextElement().toString();
981 String value = properties.getProperty(name);
982 if (name.equalsIgnoreCase(DEFAULT_JAVA_HOME_PROP_NAME) ||
983 name.equalsIgnoreCase(DEFAULT_JAVA_ARGS_PROP_NAME) ||
984 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_HOME_PROP_NAME) ||
985 name.equalsIgnoreCase(OVERWRITE_ENV_JAVA_ARGS_PROP_NAME))
986 {
987 // Already handled
988 }
989 else if (name.endsWith(".java-args"))
990 {
991 String scriptName = name.substring(0,
992 name.length() - ".java-args".length());
993 buf.append(
994 ":check"+scriptName+"JavaArgs"+EOL+
995 "set OPENDS_JAVA_ARGS="+value+EOL+
996 "goto end"+EOL+EOL);
997 }
998 }
999
1000 buf.append(":end"+EOL);
1001
1002 return buf.toString();
1003 }
1004 }