| // |
| // ======================================================================== |
| // Copyright (c) 1995-2016 Mort Bay Consulting Pty. Ltd. |
| // ------------------------------------------------------------------------ |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // and Apache License v2.0 which accompanies this distribution. |
| // |
| // The Eclipse Public License is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // The Apache License v2.0 is available at |
| // http://www.opensource.org/licenses/apache2.0.php |
| // |
| // You may elect to redistribute this code under either of these licenses. |
| // ======================================================================== |
| // |
| |
| package org.eclipse.jetty.start; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.net.URL; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.jetty.start.Props.Prop; |
| import org.eclipse.jetty.start.config.ConfigSource; |
| import org.eclipse.jetty.start.config.ConfigSources; |
| import org.eclipse.jetty.start.config.DirConfigSource; |
| |
| import static org.eclipse.jetty.start.UsageException.ERR_BAD_ARG; |
| |
| /** |
| * The Arguments required to start Jetty. |
| */ |
| public class StartArgs |
| { |
| public static final String VERSION; |
| |
| static |
| { |
| // Use command line versions |
| String ver = System.getProperty("jetty.version",null); |
| String tag = System.getProperty("jetty.tag.version","master"); |
| |
| // Use META-INF/MANIFEST.MF versions |
| if (ver == null) |
| { |
| Package pkg = StartArgs.class.getPackage(); |
| if ((pkg != null) && "Eclipse.org - Jetty".equals(pkg.getImplementationVendor()) && (pkg.getImplementationVersion() != null)) |
| { |
| ver = pkg.getImplementationVersion(); |
| if (tag == null) |
| { |
| tag = "jetty-" + ver; |
| } |
| } |
| } |
| |
| // Use jetty-version.properties values |
| if (ver == null) |
| { |
| URL url = Thread.currentThread().getContextClassLoader().getResource("jetty-version.properties"); |
| if (url != null) |
| { |
| try (InputStream in = url.openStream()) |
| { |
| Properties props = new Properties(); |
| props.load(in); |
| ver = props.getProperty("jetty.version"); |
| } |
| catch (IOException ignore) |
| { |
| StartLog.debug(ignore); |
| } |
| } |
| } |
| |
| // Default values |
| if (ver == null) |
| { |
| ver = "0.0"; |
| if (tag == null) |
| { |
| tag = "master"; |
| } |
| } |
| |
| // Set Tag Defaults |
| if (tag == null || tag.contains("-SNAPSHOT")) |
| { |
| tag = "master"; |
| } |
| |
| VERSION = ver; |
| System.setProperty("jetty.version",VERSION); |
| System.setProperty("jetty.tag.version",tag); |
| } |
| |
| private static final String SERVER_MAIN = "org.eclipse.jetty.xml.XmlConfiguration"; |
| |
| /** List of enabled modules */ |
| private Set<String> modules = new HashSet<>(); |
| |
| /** List of modules to skip [files] section validation */ |
| private Set<String> skipFileValidationModules = new HashSet<>(); |
| |
| /** Map of enabled modules to the source of where that activation occurred */ |
| private Map<String, List<String>> sources = new HashMap<>(); |
| |
| /** Map of properties to where that property was declared */ |
| private Map<String, String> propertySource = new HashMap<>(); |
| |
| /** List of all active [files] sections from enabled modules */ |
| private List<FileArg> files = new ArrayList<>(); |
| |
| /** List of all active [lib] sections from enabled modules */ |
| private Classpath classpath; |
| |
| /** List of all active [xml] sections from enabled modules */ |
| private List<Path> xmls = new ArrayList<>(); |
| |
| /** JVM arguments, found via commmand line and in all active [exec] sections from enabled modules */ |
| private List<String> jvmArgs = new ArrayList<>(); |
| |
| /** List of all xml references found directly on command line or start.ini */ |
| private List<String> xmlRefs = new ArrayList<>(); |
| |
| /** List of all property references found directly on command line or start.ini */ |
| private List<String> propertyFileRefs = new ArrayList<>(); |
| |
| /** List of all property files */ |
| private List<Path> propertyFiles = new ArrayList<>(); |
| |
| private Props properties = new Props(); |
| private Set<String> systemPropertyKeys = new HashSet<>(); |
| private List<String> rawLibs = new ArrayList<>(); |
| |
| // jetty.base - build out commands |
| /** --add-to-startd=[module,[module]] */ |
| private List<String> addToStartdIni = new ArrayList<>(); |
| /** --add-to-start=[module,[module]] */ |
| private List<String> addToStartIni = new ArrayList<>(); |
| |
| // module inspection commands |
| /** --write-module-graph=[filename] */ |
| private String moduleGraphFilename; |
| |
| /** Collection of all modules */ |
| private Modules allModules; |
| /** Should the server be run? */ |
| private boolean run = true; |
| |
| /** Download related args */ |
| private boolean download = false; |
| private boolean licenseCheckRequired = false; |
| private boolean testingMode = false; |
| |
| private boolean help = false; |
| private boolean stopCommand = false; |
| private boolean listModules = false; |
| private boolean listClasspath = false; |
| private boolean listConfig = false; |
| private boolean version = false; |
| private boolean dryRun = false; |
| |
| private boolean exec = false; |
| private String exec_properties; |
| private boolean approveAllLicenses = false; |
| |
| public StartArgs() |
| { |
| classpath = new Classpath(); |
| } |
| |
| private void addFile(Module module, String uriLocation) |
| { |
| if (module.isSkipFilesValidation()) |
| { |
| StartLog.debug("Not validating %s [files] for %s",module,uriLocation); |
| return; |
| } |
| |
| FileArg arg = new FileArg(module,properties.expand(uriLocation)); |
| if (!files.contains(arg)) |
| { |
| files.add(arg); |
| } |
| } |
| |
| public void addSystemProperty(String key, String value) |
| { |
| this.systemPropertyKeys.add(key); |
| System.setProperty(key,value); |
| } |
| |
| private void addUniqueXmlFile(String xmlRef, Path xmlfile) throws IOException |
| { |
| if (!FS.canReadFile(xmlfile)) |
| { |
| throw new IOException("Cannot read file: " + xmlRef); |
| } |
| xmlfile = FS.toRealPath(xmlfile); |
| if (!xmls.contains(xmlfile)) |
| { |
| xmls.add(xmlfile); |
| } |
| } |
| |
| private void addUniquePropertyFile(String propertyFileRef, Path propertyFile) throws IOException |
| { |
| if (!FS.canReadFile(propertyFile)) |
| { |
| throw new IOException("Cannot read file: " + propertyFileRef); |
| } |
| propertyFile = FS.toRealPath(propertyFile); |
| if (!propertyFiles.contains(propertyFile)) |
| { |
| propertyFiles.add(propertyFile); |
| } |
| } |
| |
| public void dumpActiveXmls(BaseHome baseHome) |
| { |
| System.out.println(); |
| System.out.println("Jetty Active XMLs:"); |
| System.out.println("------------------"); |
| if (xmls.isEmpty()) |
| { |
| System.out.println(" (no xml files specified)"); |
| return; |
| } |
| |
| for (Path xml : xmls) |
| { |
| System.out.printf(" %s%n",baseHome.toShortForm(xml.toAbsolutePath())); |
| } |
| } |
| |
| public void dumpEnvironment(BaseHome baseHome) |
| { |
| // Java Details |
| System.out.println(); |
| System.out.println("Java Environment:"); |
| System.out.println("-----------------"); |
| dumpSystemProperty("java.home"); |
| dumpSystemProperty("java.vm.vendor"); |
| dumpSystemProperty("java.vm.version"); |
| dumpSystemProperty("java.vm.name"); |
| dumpSystemProperty("java.vm.info"); |
| dumpSystemProperty("java.runtime.name"); |
| dumpSystemProperty("java.runtime.version"); |
| dumpSystemProperty("java.io.tmpdir"); |
| dumpSystemProperty("user.dir"); |
| dumpSystemProperty("user.language"); |
| dumpSystemProperty("user.country"); |
| |
| // Jetty Environment |
| System.out.println(); |
| System.out.println("Jetty Environment:"); |
| System.out.println("-----------------"); |
| dumpProperty("jetty.version"); |
| dumpProperty("jetty.tag.version"); |
| dumpProperty("jetty.home"); |
| dumpProperty("jetty.base"); |
| |
| // Jetty Configuration Environment |
| System.out.println(); |
| System.out.println("Config Search Order:"); |
| System.out.println("--------------------"); |
| for (ConfigSource config : baseHome.getConfigSources()) |
| { |
| System.out.printf(" %s",config.getId()); |
| if (config instanceof DirConfigSource) |
| { |
| DirConfigSource dirsource = (DirConfigSource)config; |
| if (dirsource.isPropertyBased()) |
| { |
| System.out.printf(" -> %s",dirsource.getDir()); |
| } |
| } |
| System.out.println(); |
| } |
| |
| // Jetty Se |
| System.out.println(); |
| } |
| |
| public void dumpJvmArgs() |
| { |
| System.out.println(); |
| System.out.println("JVM Arguments:"); |
| System.out.println("--------------"); |
| if (jvmArgs.isEmpty()) |
| { |
| System.out.println(" (no jvm args specified)"); |
| return; |
| } |
| |
| for (String jvmArgKey : jvmArgs) |
| { |
| String value = System.getProperty(jvmArgKey); |
| if (value != null) |
| { |
| System.out.printf(" %s = %s%n",jvmArgKey,value); |
| } |
| else |
| { |
| System.out.printf(" %s%n",jvmArgKey); |
| } |
| } |
| } |
| |
| public void dumpProperties() |
| { |
| System.out.println(); |
| System.out.println("Properties:"); |
| System.out.println("-----------"); |
| |
| List<String> sortedKeys = new ArrayList<>(); |
| for (Prop prop : properties) |
| { |
| if (prop.origin.equals(Props.ORIGIN_SYSPROP)) |
| { |
| continue; // skip |
| } |
| sortedKeys.add(prop.key); |
| } |
| |
| if (sortedKeys.isEmpty()) |
| { |
| System.out.println(" (no properties specified)"); |
| return; |
| } |
| |
| Collections.sort(sortedKeys); |
| |
| for (String key : sortedKeys) |
| { |
| dumpProperty(key); |
| } |
| } |
| |
| private void dumpProperty(String key) |
| { |
| Prop prop = properties.getProp(key); |
| if (prop == null) |
| { |
| System.out.printf(" %s (not defined)%n",key); |
| } |
| else |
| { |
| System.out.printf(" %s = %s%n",key,properties.expand(prop.value)); |
| if (StartLog.isDebugEnabled()) |
| { |
| System.out.printf(" origin: %s%n",prop.origin); |
| while (prop.overrides != null) |
| { |
| prop = prop.overrides; |
| System.out.printf(" (overrides)%n"); |
| System.out.printf(" %s = %s%n",key,properties.expand(prop.value)); |
| System.out.printf(" origin: %s%n",prop.origin); |
| } |
| } |
| } |
| } |
| |
| public void dumpSystemProperties() |
| { |
| System.out.println(); |
| System.out.println("System Properties:"); |
| System.out.println("------------------"); |
| |
| if (systemPropertyKeys.isEmpty()) |
| { |
| System.out.println(" (no system properties specified)"); |
| return; |
| } |
| |
| List<String> sortedKeys = new ArrayList<>(); |
| sortedKeys.addAll(systemPropertyKeys); |
| Collections.sort(sortedKeys); |
| |
| for (String key : sortedKeys) |
| { |
| String value = System.getProperty(key); |
| System.out.printf(" %s = %s%n",key,properties.expand(value)); |
| } |
| } |
| |
| private void dumpSystemProperty(String key) |
| { |
| System.out.printf(" %s = %s%n",key,System.getProperty(key)); |
| } |
| |
| /** |
| * Ensure that the System Properties are set (if defined as a System property, or start.config property, or |
| * start.ini property) |
| * |
| * @param key |
| * the key to be sure of |
| */ |
| private void ensureSystemPropertySet(String key) |
| { |
| if (systemPropertyKeys.contains(key)) |
| { |
| return; // done |
| } |
| |
| if (properties.containsKey(key)) |
| { |
| String val = properties.expand(properties.getString(key)); |
| if (val == null) |
| { |
| return; // no value to set |
| } |
| // setup system property |
| systemPropertyKeys.add(key); |
| System.setProperty(key,val); |
| } |
| } |
| |
| /** |
| * Expand any command line added <code>--lib</code> lib references. |
| * |
| * @param baseHome |
| * the base home in use |
| * @throws IOException |
| * if unable to expand the libraries |
| */ |
| public void expandLibs(BaseHome baseHome) throws IOException |
| { |
| StartLog.debug("Expanding Libs"); |
| for (String rawlibref : rawLibs) |
| { |
| StartLog.debug("rawlibref = " + rawlibref); |
| String libref = properties.expand(rawlibref); |
| StartLog.debug("expanded = " + libref); |
| |
| // perform path escaping (needed by windows) |
| libref = libref.replaceAll("\\\\([^\\\\])","\\\\\\\\$1"); |
| |
| for (Path libpath : baseHome.getPaths(libref)) |
| { |
| classpath.addComponent(libpath.toFile()); |
| } |
| } |
| } |
| |
| /** |
| * Build up the Classpath and XML file references based on enabled Module list. |
| * |
| * @param baseHome |
| * the base home in use |
| * @param activeModules |
| * the active (selected) modules |
| * @throws IOException |
| * if unable to expand the modules |
| */ |
| public void expandModules(BaseHome baseHome, List<Module> activeModules) throws IOException |
| { |
| StartLog.debug("Expanding Modules"); |
| for (Module module : activeModules) |
| { |
| // Find and Expand Libraries |
| for (String rawlibref : module.getLibs()) |
| { |
| StartLog.debug("rawlibref = " + rawlibref); |
| String libref = properties.expand(rawlibref); |
| StartLog.debug("expanded = " + libref); |
| |
| for (Path libpath : baseHome.getPaths(libref)) |
| { |
| classpath.addComponent(libpath.toFile()); |
| } |
| } |
| |
| for (String jvmArg : module.getJvmArgs()) |
| { |
| exec = true; |
| jvmArgs.add(jvmArg); |
| } |
| |
| // Find and Expand XML files |
| for (String xmlRef : module.getXmls()) |
| { |
| // Straight Reference |
| xmlRef = properties.expand(xmlRef); |
| Path xmlfile = baseHome.getPath(xmlRef); |
| addUniqueXmlFile(xmlRef,xmlfile); |
| } |
| |
| // Register Download operations |
| for (String file : module.getFiles()) |
| { |
| StartLog.debug("Adding module specified file: %s",file); |
| addFile(module,file); |
| } |
| } |
| } |
| |
| public List<String> getAddToStartdIni() |
| { |
| return addToStartdIni; |
| } |
| |
| public List<String> getAddToStartIni() |
| { |
| return addToStartIni; |
| } |
| |
| public Modules getAllModules() |
| { |
| return allModules; |
| } |
| |
| public Classpath getClasspath() |
| { |
| return classpath; |
| } |
| |
| public Set<String> getEnabledModules() |
| { |
| return this.modules; |
| } |
| |
| public List<FileArg> getFiles() |
| { |
| return files; |
| } |
| |
| public List<String> getJvmArgs() |
| { |
| return jvmArgs; |
| } |
| |
| public CommandLineBuilder getMainArgs(BaseHome baseHome, boolean addJavaInit) throws IOException |
| { |
| CommandLineBuilder cmd = new CommandLineBuilder(); |
| |
| if (addJavaInit) |
| { |
| cmd.addRawArg(CommandLineBuilder.findJavaBin()); |
| |
| for (String x : jvmArgs) |
| { |
| cmd.addRawArg(x); |
| } |
| |
| cmd.addRawArg("-Djava.io.tmpdir=" + System.getProperty("java.io.tmpdir")); |
| cmd.addRawArg("-Djetty.home=" + baseHome.getHome()); |
| cmd.addRawArg("-Djetty.base=" + baseHome.getBase()); |
| |
| // System Properties |
| for (String propKey : systemPropertyKeys) |
| { |
| String value = System.getProperty(propKey); |
| cmd.addEqualsArg("-D" + propKey,value); |
| } |
| |
| cmd.addRawArg("-cp"); |
| cmd.addRawArg(classpath.toString()); |
| cmd.addRawArg(getMainClassname()); |
| } |
| |
| // Special Stop/Shutdown properties |
| ensureSystemPropertySet("STOP.PORT"); |
| ensureSystemPropertySet("STOP.KEY"); |
| ensureSystemPropertySet("STOP.WAIT"); |
| |
| // pass properties as args or as a file |
| if (dryRun && exec_properties==null) |
| { |
| for (Prop p : properties) |
| cmd.addRawArg(CommandLineBuilder.quote(p.key) + "=" + CommandLineBuilder.quote(p.value)); |
| } |
| else if (properties.size() > 0) |
| { |
| Path prop_path; |
| if (exec_properties==null) |
| { |
| prop_path=Files.createTempFile("start_", ".properties"); |
| prop_path.toFile().deleteOnExit(); |
| } |
| else |
| prop_path=new File(exec_properties).toPath(); |
| |
| try (OutputStream out = Files.newOutputStream(prop_path)) |
| { |
| properties.store(out,"start.jar properties"); |
| } |
| cmd.addRawArg(prop_path.toAbsolutePath().toString()); |
| } |
| |
| for (Path xml : xmls) |
| { |
| cmd.addRawArg(xml.toAbsolutePath().toString()); |
| } |
| |
| for (Path propertyFile : propertyFiles) |
| { |
| cmd.addRawArg(propertyFile.toAbsolutePath().toString()); |
| } |
| |
| return cmd; |
| } |
| |
| public String getMainClassname() |
| { |
| String mainclass = System.getProperty("jetty.server",SERVER_MAIN); |
| return System.getProperty("main.class",mainclass); |
| } |
| |
| public Path getMavenLocalRepoDir() |
| { |
| // Try property first |
| String localRepo = getProperties().getString("maven.local.repo"); |
| |
| if (Utils.isBlank(localRepo)) |
| { |
| // Try jetty specific env variable |
| localRepo = System.getenv("JETTY_MAVEN_LOCAL_REPO"); |
| } |
| |
| if (Utils.isBlank(localRepo)) |
| { |
| // Try generic env variable |
| localRepo = System.getenv("MAVEN_LOCAL_REPO"); |
| } |
| |
| // TODO: load & use $HOME/.m2/settings.xml ? |
| // TODO: possibly use Eclipse Aether to manage it ? |
| // TODO: see https://bugs.eclipse.org/bugs/show_bug.cgi?id=449511 |
| |
| // Still blank? then its not specified |
| if (Utils.isBlank(localRepo)) |
| { |
| return null; |
| } |
| |
| Path localRepoDir = new File(localRepo).toPath(); |
| localRepoDir = localRepoDir.normalize().toAbsolutePath(); |
| if (Files.exists(localRepoDir) && Files.isDirectory(localRepoDir)) |
| { |
| return localRepoDir; |
| } |
| |
| StartLog.warn("Not a valid maven local repository directory: %s",localRepoDir); |
| |
| // Not a valid repository directory, skip it |
| return null; |
| } |
| |
| public String getModuleGraphFilename() |
| { |
| return moduleGraphFilename; |
| } |
| |
| public Props getProperties() |
| { |
| return properties; |
| } |
| |
| public Set<String> getSkipFileValidationModules() |
| { |
| return skipFileValidationModules; |
| } |
| |
| public List<String> getSources(String module) |
| { |
| return sources.get(module); |
| } |
| |
| public List<Path> getXmlFiles() |
| { |
| return xmls; |
| } |
| |
| public boolean hasJvmArgs() |
| { |
| return jvmArgs.size() > 0; |
| } |
| |
| public boolean hasSystemProperties() |
| { |
| for (String key : systemPropertyKeys) |
| { |
| // ignored keys |
| if ("jetty.home".equals(key) || "jetty.base".equals(key) || "main.class".equals(key)) |
| { |
| // skip |
| continue; |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean isApproveAllLicenses() |
| { |
| return approveAllLicenses; |
| } |
| |
| public boolean isDownload() |
| { |
| return download; |
| } |
| |
| public boolean isDryRun() |
| { |
| return dryRun; |
| } |
| |
| public boolean isExec() |
| { |
| return exec; |
| } |
| |
| public boolean isLicenseCheckRequired() |
| { |
| return licenseCheckRequired; |
| } |
| |
| public boolean isNormalMainClass() |
| { |
| return SERVER_MAIN.equals(getMainClassname()); |
| } |
| |
| public boolean isHelp() |
| { |
| return help; |
| } |
| |
| public boolean isListClasspath() |
| { |
| return listClasspath; |
| } |
| |
| public boolean isListConfig() |
| { |
| return listConfig; |
| } |
| |
| public boolean isListModules() |
| { |
| return listModules; |
| } |
| |
| public boolean isRun() |
| { |
| return run; |
| } |
| |
| public boolean isStopCommand() |
| { |
| return stopCommand; |
| } |
| |
| public boolean isTestingModeEnabled() |
| { |
| return testingMode; |
| } |
| |
| public boolean isVersion() |
| { |
| return version; |
| } |
| |
| public void parse(ConfigSources sources) |
| { |
| ListIterator<ConfigSource> iter = sources.reverseListIterator(); |
| while (iter.hasPrevious()) |
| { |
| ConfigSource source = iter.previous(); |
| for (RawArgs.Entry arg : source.getArgs()) |
| { |
| parse(arg.getLine(),arg.getOrigin()); |
| } |
| } |
| } |
| |
| public void parse(final String rawarg, String source) |
| { |
| parse(rawarg,source,true); |
| } |
| |
| /** |
| * Parse a single line of argument. |
| * |
| * @param rawarg |
| * the raw argument to parse |
| * @param source |
| * the origin of this line of argument |
| * @param replaceProps |
| * true if properties in this parse replace previous ones, false to not replace. |
| */ |
| private void parse(final String rawarg, String source, boolean replaceProps) |
| { |
| if (rawarg == null) |
| { |
| return; |
| } |
| |
| StartLog.debug("parse(\"%s\", \"%s\", %b)",rawarg,source,replaceProps); |
| |
| final String arg = rawarg.trim(); |
| |
| if (arg.length() <= 0) |
| { |
| return; |
| } |
| |
| if (arg.startsWith("#")) |
| { |
| return; |
| } |
| |
| if ("--help".equals(arg) || "-?".equals(arg)) |
| { |
| help = true; |
| run = false; |
| return; |
| } |
| |
| if ("--debug".equals(arg) || arg.startsWith("--start-log-file")) |
| { |
| // valid, but handled in StartLog instead |
| return; |
| } |
| |
| if ("--testing-mode".equals(arg)) |
| { |
| System.setProperty("org.eclipse.jetty.start.testing","true"); |
| testingMode = true; |
| return; |
| } |
| |
| if (arg.startsWith("--include-jetty-dir=")) |
| { |
| // valid, but handled in ConfigSources instead |
| return; |
| } |
| |
| if ("--stop".equals(arg)) |
| { |
| stopCommand = true; |
| run = false; |
| return; |
| } |
| |
| if (arg.startsWith("--download=")) |
| { |
| addFile(null,Props.getValue(arg)); |
| run = false; |
| download = true; |
| return; |
| } |
| |
| if (arg.equals("--create-files")) |
| { |
| run = false; |
| download = true; |
| licenseCheckRequired = true; |
| return; |
| } |
| |
| if ("--list-classpath".equals(arg) || "--version".equals(arg) || "-v".equals(arg) || "--info".equals(arg)) |
| { |
| listClasspath = true; |
| run = false; |
| return; |
| } |
| |
| if ("--list-config".equals(arg)) |
| { |
| listConfig = true; |
| run = false; |
| return; |
| } |
| |
| if ("--dry-run".equals(arg) || "--exec-print".equals(arg)) |
| { |
| dryRun = true; |
| run = false; |
| return; |
| } |
| |
| // Enable forked execution of Jetty server |
| if ("--exec".equals(arg)) |
| { |
| exec = true; |
| return; |
| } |
| |
| // Assign a fixed name to the property file for exec |
| if (arg.startsWith("--exec-properties=")) |
| { |
| exec_properties=Props.getValue(arg); |
| if (!exec_properties.endsWith(".properties")) |
| throw new UsageException(ERR_BAD_ARG,"--exec-properties filename must have .properties suffix: %s",exec_properties); |
| return; |
| } |
| |
| // Enable forked execution of Jetty server |
| if ("--approve-all-licenses".equals(arg)) |
| { |
| approveAllLicenses = true; |
| return; |
| } |
| |
| // Arbitrary Libraries |
| if (arg.startsWith("--lib=")) |
| { |
| String cp = Props.getValue(arg); |
| |
| if (cp != null) |
| { |
| StringTokenizer t = new StringTokenizer(cp,File.pathSeparator); |
| while (t.hasMoreTokens()) |
| { |
| rawLibs.add(t.nextToken()); |
| } |
| } |
| return; |
| } |
| |
| // Module Management |
| if ("--list-modules".equals(arg)) |
| { |
| listModules = true; |
| run = false; |
| return; |
| } |
| |
| // jetty.base build-out : add to ${jetty.base}/start.d/ |
| if (arg.startsWith("--add-to-startd=")) |
| { |
| List<String> moduleNames = Props.getValues(arg); |
| addToStartdIni.addAll(moduleNames); |
| run = false; |
| download = true; |
| licenseCheckRequired = true; |
| return; |
| } |
| |
| // jetty.base build-out : add to ${jetty.base}/start.ini |
| if (arg.startsWith("--add-to-start=")) |
| { |
| List<String> moduleNames = Props.getValues(arg); |
| addToStartIni.addAll(moduleNames); |
| run = false; |
| download = true; |
| licenseCheckRequired = true; |
| return; |
| } |
| |
| // Enable a module |
| if (arg.startsWith("--module=")) |
| { |
| List<String> moduleNames = Props.getValues(arg); |
| enableModules(source,moduleNames); |
| return; |
| } |
| |
| // Skip [files] validation on a module |
| if (arg.startsWith("--skip-file-validation=")) |
| { |
| List<String> moduleNames = Props.getValues(arg); |
| for (String moduleName : moduleNames) |
| { |
| skipFileValidationModules.add(moduleName); |
| } |
| return; |
| } |
| |
| // Create graphviz output of module graph |
| if (arg.startsWith("--write-module-graph=")) |
| { |
| this.moduleGraphFilename = Props.getValue(arg); |
| run = false; |
| return; |
| } |
| |
| // Start property (syntax similar to System property) |
| if (arg.startsWith("-D")) |
| { |
| String[] assign = arg.substring(2).split("=",2); |
| systemPropertyKeys.add(assign[0]); |
| switch (assign.length) |
| { |
| case 2: |
| System.setProperty(assign[0],assign[1]); |
| setProperty(assign[0],assign[1],source,replaceProps); |
| break; |
| case 1: |
| System.setProperty(assign[0],""); |
| setProperty(assign[0],"",source,replaceProps); |
| break; |
| default: |
| break; |
| } |
| return; |
| } |
| |
| // Anything else with a "-" is considered a JVM argument |
| if (arg.startsWith("-")) |
| { |
| // Only add non-duplicates |
| if (!jvmArgs.contains(arg)) |
| { |
| jvmArgs.add(arg); |
| } |
| return; |
| } |
| |
| // Is this a raw property declaration? |
| int idx = arg.indexOf('='); |
| if (idx >= 0) |
| { |
| String key = arg.substring(0,idx); |
| String value = arg.substring(idx + 1); |
| |
| if (replaceProps) |
| { |
| if (propertySource.containsKey(key)) |
| { |
| StartLog.warn("Property %s in %s already set in %s",key,source,propertySource.get(key)); |
| } |
| propertySource.put(key,source); |
| } |
| |
| if ("OPTION".equals(key) || "OPTIONS".equals(key)) |
| { |
| StringBuilder warn = new StringBuilder(); |
| warn.append("The behavior of the argument "); |
| warn.append(arg).append(" (seen in ").append(source); |
| warn.append(") has changed, and is now considered a normal property. "); |
| warn.append(key).append(" no longer controls what libraries are on your classpath,"); |
| warn.append(" use --module instead. See --help for details."); |
| StartLog.warn(warn.toString()); |
| } |
| |
| setProperty(key,value,source,replaceProps); |
| return; |
| } |
| |
| // Is this an xml file? |
| if (FS.isXml(arg)) |
| { |
| // only add non-duplicates |
| if (!xmlRefs.contains(arg)) |
| { |
| xmlRefs.add(arg); |
| } |
| return; |
| } |
| |
| if (FS.isPropertyFile(arg)) |
| { |
| // only add non-duplicates |
| if (!propertyFileRefs.contains(arg)) |
| { |
| propertyFileRefs.add(arg); |
| } |
| return; |
| } |
| |
| // Anything else is unrecognized |
| throw new UsageException(ERR_BAD_ARG,"Unrecognized argument: \"%s\" in %s",arg,source); |
| } |
| |
| private void enableModules(String source, List<String> moduleNames) |
| { |
| for (String moduleName : moduleNames) |
| { |
| modules.add(moduleName); |
| List<String> list = sources.get(moduleName); |
| if (list == null) |
| { |
| list = new ArrayList<String>(); |
| sources.put(moduleName,list); |
| } |
| list.add(source); |
| } |
| } |
| |
| public void parseModule(Module module) |
| { |
| if (module.hasDefaultConfig()) |
| { |
| for (String line : module.getDefaultConfig()) |
| { |
| parse(line,module.getFilesystemRef(),false); |
| } |
| } |
| } |
| |
| public void resolveExtraXmls(BaseHome baseHome) throws IOException |
| { |
| // Find and Expand XML files |
| for (String xmlRef : xmlRefs) |
| { |
| // Straight Reference |
| Path xmlfile = baseHome.getPath(xmlRef); |
| if (!FS.exists(xmlfile)) |
| { |
| xmlfile = baseHome.getPath("etc/" + xmlRef); |
| } |
| addUniqueXmlFile(xmlRef,xmlfile); |
| } |
| } |
| |
| public void resolvePropertyFiles(BaseHome baseHome) throws IOException |
| { |
| // Find and Expand property files |
| for (String propertyFileRef : propertyFileRefs) |
| { |
| // Straight Reference |
| Path propertyFile = baseHome.getPath(propertyFileRef); |
| if (!FS.exists(propertyFile)) |
| { |
| propertyFile = baseHome.getPath("etc/" + propertyFileRef); |
| } |
| addUniquePropertyFile(propertyFileRef,propertyFile); |
| } |
| } |
| |
| public void setAllModules(Modules allModules) |
| { |
| this.allModules = allModules; |
| } |
| |
| public void setProperty(String key, String value, String source, boolean replaceProp) |
| { |
| // Special / Prevent override from start.ini's |
| if (key.equals("jetty.home")) |
| { |
| properties.setProperty("jetty.home",System.getProperty("jetty.home"),source); |
| return; |
| } |
| |
| // Special / Prevent override from start.ini's |
| if (key.equals("jetty.base")) |
| { |
| properties.setProperty("jetty.base",System.getProperty("jetty.base"),source); |
| return; |
| } |
| |
| if (replaceProp || (!properties.containsKey(key))) |
| { |
| properties.setProperty(key,value,source); |
| if(key.equals("java.version")) |
| { |
| Version ver = new Version(value); |
| |
| properties.setProperty("java.version",ver.toShortString(),source); |
| properties.setProperty("java.version.major",Integer.toString(ver.getLegacyMajor()),source); |
| properties.setProperty("java.version.minor",Integer.toString(ver.getMajor()),source); |
| properties.setProperty("java.version.revision",Integer.toString(ver.getRevision()),source); |
| properties.setProperty("java.version.update",Integer.toString(ver.getUpdate()),source); |
| } |
| } |
| } |
| |
| public void setRun(boolean run) |
| { |
| this.run = run; |
| } |
| |
| @Override |
| public String toString() |
| { |
| StringBuilder builder = new StringBuilder(); |
| builder.append("StartArgs [enabledModules="); |
| builder.append(modules); |
| builder.append(", xmlRefs="); |
| builder.append(xmlRefs); |
| builder.append(", properties="); |
| builder.append(properties); |
| builder.append(", jvmArgs="); |
| builder.append(jvmArgs); |
| builder.append("]"); |
| return builder.toString(); |
| } |
| } |