Usage: java -jar start.jar [options...] [properties...] [configs...]

  The start.jar builds a classpath and executes a main java class with
  a classloader built from that classpath.  By default the start.jar
  mechanism is configured to start the jetty server, but it can be
  configured to start any java main class.

Command Line Options:
---------------------

  --help           This help / usage information.

  --version        Print the version information for Jetty and
                   dependent jars, then exit.

  --list-classpath Print the classpath information that will be used to start
                   Jetty

  --list-config    List the resolved configuration that will be used to
                   start Jetty.
                   Output includes:
                     o  Enabled jetty modules
                     o  Java Environment
                     o  Jetty Environment
                     o  Config file search order
                     o  JVM Arguments
                     o  System Properties
                     o  Properties
                     o  Java Classpath
                     o  XML Configuration files

  --dry-run        Print the command line that the start.jar generates,
                   then exit. This may be used to generate command lines
                   when the start.ini includes -X or -D arguments:

                     java -jar start.jar --dry-run > jetty.sh
                     . jetty.sh

  --dry-run=parts  Print specific parts of the command line. The parts
                   are a comma separated list of
                     o  "java" - the JVM to run
                     o  "opts" - the JVM options (eg -D and -X flags)
                     o  "path" - the JVM class path or JPMS modules options
                     o  "main" - the main class to run
                     o  "args" - the arguments passed to the main class

                   It is possible to decompose the start command:

                     OPTS=$(java -jar start.jar --dry-run=opts,path)
                     MAIN=$(java -jar start.jar --dry-run=main)
                     ARGS=$(java -jar start.jar --dry-run=args)
                     java $OPTS -Dextra=opt $MAIN $ARGS extra=arg

                   Alternatively to create an args file for java:

                     java -jar start.jar --dry-run=opts,path,main,args > /tmp/args
                     java @/tmp/args

  --exec           Run the generated command line (see --dry-run) in
                   a sub process. This can be used when start.ini
                   contains -X or -D arguments, but creates an extra
                   JVM instance.
                   
  --exec-properties=<filename>
                   Assign a fixed name to the file used to transfer 
                   properties to the sub process. This allows the 
                   generated properties file to be saved and reused.
                   Without this option, a temporary file is used.
                   
  --commands=<filename>
                   Use each line of the file as arguments on the command
                   line.

Debug and Start Logging:
------------------------

  --debug          Enable debug output of the startup procedure.
                   Note: this does not setup debug for Jetty itself.
                   If you want debug for Jetty, configure your logging.
                   https://www.eclipse.org/jetty/documentation/

  --start-log-file=<filename>
                   A filename, relative to ${jetty.base}, where all startup
                   output will be sent.  This is useful for capturing startup
                   issues where the jetty specific logger has not yet kicked
                   in due to startup configuration errors.

Jetty Module Management:
------------------------

  --list-modules   List Jetty modules defined in ${jetty.base}/modules/*.mod and
                   then ${jetty.home}/modules/*.mod

  --list-modules=<tag>(,<tag>)*
                   List modules by tag. Use '*' for all tags. Prefix a tag 
                   with '-' to exclude the tag.  The special tag "internal"
                   is always excluded unless it is explicitly included.
                   
  --list-all-modules
                   List all modules.

  --show-modules=<module>(,<module>)*
                   Show the detail of the listed modules, including
                   dependencies, tags, libraries and XMLs

  --module=<modulename>(,<modulename>)*
                   Enable a module for this run.  To enable a module for all
                   future runs, use --add-module
                   Note: this option is used in the ${jetty.base}/start.ini
                   or ${jetty.base}/start.d/*.ini files created by --add-module.
                   
  --add-module=<modulename>(,<modulename>)*
                   Add the modules to the list of modules enabled at start. 
                   Transitive dependencies are followed and dependent
                   modules may also explicitly added.
                   Modules are added to the start by creating an ini file
                   that contains the --module argument and any other parameters
                   defined in the modules ini template.                    
                   If the ${jetty.base}/start.ini file exists, configuration is
                   appended, otherwise the directory ${jetty.base}/start.d
                   is used to create <modulename>.ini files.
                   If the ini template contains properties, these may be 
                   amended in the generated file by specifying those 
                   properties on the command line.

                   If a module is transitively enabled, its ini file will not
                   be generated. An explicit --add-module is required to generate
                   an ini file.

                   This option replaces the deprecated --add-to-start and --add-to-startd.

  --update-ini     Scan all start.ini and start.d/*.ini files and update
                   any properties with values specified on the command
                   line. e.g. --update-ini jetty.http.port=8888

  --create-start-d
                   Create a ${jetty.base}/start.d directory.  If a ${jetty.base}/start.ini
                   files exists, then it is moved into start.d.  Using a start.d directory
                   is the default and this option is only needed to either force the creation of a
                   ${jetty.home}/start.d or to move a start.ini file to start.d

  --create-start-ini
                   Create a ${jetty.base}/start.ini file.  If a ${jetty.base}/start.d
                   directory exists, then all its contained ini files are concatenated into
                   the start.ini file.

  --write-module-graph=<filename>
                   Create a graphviz *.dot file of the module graph as it
                   exists for the active ${jetty.base}.
                   See http://graphviz.org/ for details on how to post-process
                   this file into the output best suited for your needs.

  --create-files   Create any missing files that are required by initialized
                   modules.  This may download a file from the network if the
                   module provides a URL.

  --skip-file-validation=<modulename>(,<modulename)*
                   Disable the [files] section validation of content
                   in the ${jetty.base} directory for a specific
                   module.  Useful for modules that have downloadable
                   content that is being overridden with alternatives
                   in the ${jetty.base} directory.
                   CAUTION:
                     This advanced option is for administrators that
                     fully understand the configuration of their
                     ${jetty.base} and are willing to forego some of the
                     safety checks built into the jetty-start mechanism.

  --approve-all-licenses
                   Approve all license questions. Useful for enabling
                   modules from a script that does not require user interaction.

Startup / Shutdown Command Line:
--------------------------------

  --stop           Send a stop signal to the running Jetty instance.
                   The server must have been started with a STOP.PORT=<port>
                   property set and the stop command must have the same property.

Advanced Commands:
------------------

  --lib=<classpath>
                   Add arbitrary classpath entries to the the server classpath.

  --include-jetty-dir=<path>
                   Include an extra jetty directory to use as a source
                   for configuration details.  This directory behaves similarly
                   to ${jetty.base} but sits at a layer between ${jetty.base}
                   and ${jetty.home}.  This allows for some complex hierarchies
                   of configuration details.

  --download=<http-uri>|<location>
                   Advanced usage, If the file does not exist at the given
                   location, download it from the given http URI.
                   Notes: location is always relative to ${jetty.base}.
                          you might need to escape the slash "\|" to use
                          this on some environments.
  maven.repo.uri=[url]
                  The url to use to download Maven dependencies.
                  Default is https://repo1.maven.org/maven2/.


Properties:
-----------
  Properties are used to parameterize:
    + XML files using the <Property name="pname"/> element 
    + Module files using the ${pname} syntax

  Properties and System Properties may be set on the command line, 
  in a ini file or in a [ini] section of a module using the following syntax:

    name=value
      Set a property that can be expanded in XML files with the <Property> element.

    name+=value
      Append value to an existing property value.
      
    name+=,value
      Append value to an existing property value, using a comma separator if needed.

    name?=value
      Set a property only if it is not already set.

  If any of the previous formats is preceded by -D, then a system property is set 
  as well as a start property.
   
  Each module may define its own properties. Start properties defined include:

    jetty.home=[directory]
      Set the home directory of the jetty distribution.

    jetty.base=[directory]
      Set the jetty configuration directory.  This is where the etc, webapps and start
      files will be looked for. If not found in jetty.base, they are looked for in
      jetty.home.

    STOP.HOST=[string]
      The host to use to stop the running Jetty server (defaults to 127.0.0.1)
      Required along with STOP.PORT if you want to use the --stop option above.
      
    STOP.PORT=[number]
      The port to use to stop the running Jetty server.
      Required along with STOP.KEY if you want to use the --stop option above.

    STOP.KEY=[alphanumeric]
      The passphrase defined to stop the server.
      Required along with STOP.PORT if you want to use the --stop option above.

    STOP.WAIT=[number]
      The time (in seconds) to wait for confirmation that the running
      Jetty server has stopped. If not specified, the stopper will wait
      indefinitely. Use in conjunction with the --stop option.

    maven.repo.uri=[url] default https://repo1.maven.org/maven2/.
      The url to use to download Maven dependencies.


Defaults:
---------

  Command line arguments can come from any jetty configuration directory
  (except ${jetty.home}), such as ${jetty.base} and any added jetty directories
  (see --include-jetty-dir=<path>).  
  The contents of <path>/start.ini and <path>/start.d/*.ini are all used
  to build up your command line arguments.
  In case of a conflict, the resolution of who wins, will look like this.
    
    1) <command-line itself>
    2) ${jetty.base}/start.ini
    3) ${jetty.base}/start.d/*.ini
    4) <jetty-dir>/start.ini
    5) <jetty-dir>/start.d/*.ini

For more information on startup, see the online documentation at
    https://www.eclipse.org/jetty/documentation/
