Jetty Logo
Version: 9.4.0.RC0
Contact the core Jetty developers at www.webtide.com

private support for your internal/customer projects ... custom extensions and distributions ... versioned snapshots for indefinite support ... scalability guidance for your apps and Ajax/Comet projects ... development services for sponsored feature development

Managing Startup Modules

Enabling Modules
Start.ini vs. Start.d
Configuring Modules
Disabling Modules
Listing Available and Active Modules

Jetty 9.1 a new Module system replacing the previous start.config + OPTIONS techniques from past Jetty Distributions.

The standard Jetty Distribution ships with several modules defined in ${jetty.home}/modules/.

What a Jetty Startup Module Defines:

A Module Name
The name of the module is the keyword used by the --module=<name> command line argument to activate/enable modules, and also find dependent modules. The filename of the module defines its name (eg: server.mod becomes the module named "server").
List of Dependant Modules
All modules can declare that they depend on other modules with the [depend] section. The list of dependencies is used to transitively resolve other modules that are deemed to be required based on the modules that you activate. The order of modules defined in the graph of active modules is used to determine various execution order for configuration, such as Jetty IoC XML configurations, and to resolve conflicting property declarations. Of note: there is a special section [optional] used to describe structurally dependent modules that are not technically required, but might be of use to your specific configuration.
List of Libraries
Module can optionally declare that they have libraries that they need to function properly. The [lib] section declares a set of pathnames that follow the Jetty Base and Jetty Home path resolution rules.
List of Jetty IoC XML Configurations
A Module can optionally declare a list of Jetty IoC XML configurations used to wire up the functionality that this module defines. The [xml] section declares a set of pathnames that follow the Jetty Base and Jetty Home path resolution rules. Ideally, all XML files are parameterized to accept properties to configure the various elements of the standard configuration. Allowing for a simplified configuration of Jetty for the vast majority of deployments. The execution order of the Jetty IoC XML configurations is determined by the graph of active module dependencies resolved via the [depend] sections. If the default XML is not sufficient to satisfy your needs, you can override this XML by making your own in the ${jetty.base}/etc/ directory, with the same name. The resolution steps for Jetty Base and Jetty Home will ensure that your copy from ${jetty.base} will be picked up over the default one in ${jetty.home}.
Jetty INI Template
Each module can optionally declare a startup ini template that is used to insert/append/inject sample configuration elements into the start.ini or start.d/*.ini files when using the --add-to-start=<name> command line argument in start.jar. Commonly used to present some of the parameterized property options from the Jetty IoC XML configuration files also referenced in the same module. The [ini-template] section declares this section of sample configuration.
Required Files and Directories

If the activation of a module requires some paths to exist, the [files] section defines them. There are 2 modes of operation of the entries in this section.

Ensure Directory Exists
If you add a pathname that ends in "/" (slash), such as "webapps/", then that directory will be created if it does not yet exist in ${jetty.base}/<pathname> (eg: "webapps/" will result in ${jetty.base}/webapps/ being created).
Download File
There is a special syntax to allow you to download a file into a specific location if it doesn’t exist yet: <url>:<pathname>. Currently, the <url> must be a http:// scheme URL (please let us know if you need more schemes supported). The <pathname> portion follows the Jetty Base and Jetty Home path resolution rules. Example: http://repo.corp.com/maven/corp-security-policy-1.0.jar:lib/corp-security-policy.jar This will check for the existence of lib/corp-security-policy.jar, and if it doesn’t exist, it will download the jar file from http://repo.corp.com/maven/corp-security-policy-1.0.jar

Enabling Modules

Tip

The default distribution has a co-mingled ${jetty.home} and ${jetty.base} where the directories for ${jetty.home} and ${jetty.base} point to the same location. It is highly encouraged that you learn about the differences in Jetty Base vs Jetty Home and take full advantage of this setup.

Jetty ships with many modules defined in ${jetty.home}/modules. Enabling a module is a simple process: simply add the --add-to-start syntax on the command line. Doing this will enable the module and any dependent modules.

An example of this, with a new, empty, base directory. We can see from this output, that the directory is new.

[jetty]$ mkdir mybase
[jetty]$ cd mybase
[mybase]$ ls -la
total 0
drwxr-xr-x   2 staff  staff   68 Jul 12 17:29 .
drwxr-xr-x  20 staff  staff  680 Jul 12 17:29 ..

[mybase]$ java -jar $JETTY_HOME/start.jar
WARNING: Nothing to start, exiting ...

Usage: java -jar start.jar [options] [properties] [configs]
       java -jar start.jar --help  # for more information

Lets see what the configuration looks like so far:

[mybase]$ java -jar /opt/jetty-distribution/start.jar --list-config

Java Environment:
-----------------
 java.home = /Library/Java/JavaVirtualMachines/jdk1.8.0_92.jdk/Contents/Home/jre
 java.vm.vendor = Oracle Corporation
 java.vm.version = 25.92-b14
 java.vm.name = Java HotSpot(TM) 64-Bit Server VM
 java.vm.info = mixed mode
 java.runtime.name = Java(TM) SE Runtime Environment
 java.runtime.version = 1.8.0_92-b14
 java.io.tmpdir = /var/folders/h6/yb_lbnnn11g0y1jjlvqg631h0000gn/T/
 user.dir = /Users/staff/installs/repository/jetty-distribution-9.4.0/mybase
 user.language = en
 user.country = US

Jetty Environment:
-----------------
 jetty.version = 9.4.0.RC0
 jetty.tag.version = master
 jetty.home = /Users/staff/installs/repository/jetty-distribution-9.4.0
 jetty.base = /Users/staff/installs/repository/jetty-distribution-9.4.0/mybase

Config Search Order:
--------------------
 <command-line>
 ${jetty.base} -> /Users/staff/installs/repository/jetty-distribution-9.4.0/mybase
 ${jetty.home} -> /Users/staff/installs/repository/jetty-distribution-9.4.0


JVM Arguments:
--------------
 (no jvm args specified)

System Properties:
------------------
 (no system properties specified)

Properties:
-----------
 java.version = 1.8.0_92
 java.version.major = 1
 java.version.minor = 8
 java.version.revision = 0
 java.version.update = 92

Jetty Server Classpath:
-----------------------
No classpath entries and/or version information available show.

Jetty Active XMLs:
------------------
 (no xml files specified)

Lets try adding some basic support for webapps, with automatic deploy (hot deploy), and a single basic HTTP/1.1 connector.

[mybase]$ java -jar ../start.jar --add-to-start=http,webapp,deploy
INFO : webapp          initialised in ${jetty.base}/start.d/webapp.ini
INFO : server          initialised (transitively) in ${jetty.base}/start.d/server.ini
INFO : http            initialised in ${jetty.base}/start.d/http.ini
INFO : deploy          initialised in ${jetty.base}/start.d/deploy.ini
MKDIR: ${jetty.base}/webapps
INFO : Base directory was modified

This created the webapps directory in our mybase directory and appended the start.ini file with the ini template arguments from the associated module files. Additionally, where needed, Jetty enabled any module dependencies and added their module ini template properties.

Lets see what it looks like configuration wise.

[mybase]$ java -jar ../start.jar --list-config

Java Environment:
-----------------
 java.home = /Library/Java/JavaVirtualMachines/jdk1.8.0_92.jdk/Contents/Home/jre
 java.vm.vendor = Oracle Corporation
 java.vm.version = 25.92-b14
 java.vm.name = Java HotSpot(TM) 64-Bit Server VM
 java.vm.info = mixed mode
 java.runtime.name = Java(TM) SE Runtime Environment
 java.runtime.version = 1.8.0_92-b14
 java.io.tmpdir = /var/folders/h6/yb_lbnnn11g0y1jjlvqg631h0000gn/T/
 user.dir = /Users/staff/installs/repository/jetty-distribution-9.4.0/mybase
 user.language = en
 user.country = US

Jetty Environment:
-----------------
 jetty.version = 9.4.0.RC0
 jetty.tag.version = master
 jetty.home = /Users/staff/installs/repository/jetty-distribution-9.4.0
 jetty.base = /Users/staff/installs/repository/jetty-distribution-9.4.0/mybase

Config Search Order:
--------------------
 <command-line>
 ${jetty.base} -> /Users/staff/installs/repository/jetty-distribution-9.4.0/mybase
 ${jetty.home} -> /Users/staff/installs/repository/jetty-distribution-9.4.0


JVM Arguments:
--------------
 (no jvm args specified)

System Properties:
------------------
 (no system properties specified)

Properties:
-----------
 java.version = 1.8.0_92
 java.version.major = 1
 java.version.minor = 8
 java.version.revision = 0
 java.version.update = 92

Jetty Server Classpath:
-----------------------
Version Information on 11 entries in the classpath.
Note: order presented here is how they would appear on the classpath.
      changes to the --module=name command line options will be reflected here.
 0:                    3.1.0 | ${jetty.home}/lib/servlet-api-3.1.jar
 1:                 3.1.0.M0 | ${jetty.home}/lib/jetty-schemas-3.1.jar
 2:           9.4.0.RC0 | ${jetty.home}/lib/jetty-http-9.4.0.RC0.jar
 3:           9.4.0.RC0 | ${jetty.home}/lib/jetty-server-9.4.0.RC0.jar
 4:           9.4.0.RC0 | ${jetty.home}/lib/jetty-xml-9.4.0.RC0.jar
 5:           9.4.0.RC0 | ${jetty.home}/lib/jetty-util-9.4.0.RC0.jar
 6:           9.4.0.RC0 | ${jetty.home}/lib/jetty-io-9.4.0.RC0.jar
 7:           9.4.0.RC0 | ${jetty.home}/lib/jetty-security-9.4.0.RC0.jar
 8:           9.4.0.RC0 | ${jetty.home}/lib/jetty-servlet-9.4.0.RC0.jar
 9:           9.4.0.RC0 | ${jetty.home}/lib/jetty-webapp-9.4.0.RC0.jar
10:           9.4.0.RC0 | ${jetty.home}/lib/jetty-deploy-9.4.0.RC0.jar

Jetty Active XMLs:
------------------
 ${jetty.home}/etc/jetty.xml
 ${jetty.home}/etc/jetty-deploy.xml
 ${jetty.home}/etc/jetty-http.xml

You now have a configured and functional server, albeit with no webapps deployed. At this point you can place a webapp (war file) in the mybase/webapps/ directory and and start Jetty.

Start.ini vs. Start.d

In the above example, when a module is activated the contents of that module file are added in ${jetty.base}/start.ini. As additional modules are added, their contents are appended to this file. This can be beneficial if you want all of your module configurations in a single file, but for large server instances with lots of modules it can pose a challenge to quickly find and make changes or to remove a module.

As an alternative to a single start.ini file you can opt to house modules in a ${jetty.base}/start.d directory. Modules activated when a start.d directory exists will be stored as a single file per module. Below is an example of a fresh ${jetty.base} that will create a start.d directory and activate several modules.

[jetty.home]$ mkdir mybase
[jetty.home]$ cd mybase/
[mybase]$ java -jar ../start.jar --create-startd
INFO : Base directory was modified
[mybase]$ ls -all
total 0
drwxr-xr-x   3 staff  staff  102 Aug 29 15:16 .
drwxr-xr-x@ 26 staff  staff  884 Aug 29 15:16 ..
drwxr-xr-x   6 staff  staff  204 Aug 29 15:19 start.d

[mybase]$ java -jar ../start.jar --add-to-start=server,client,webapp,websocket
INFO : webapp          initialised in ${jetty.base}/start.d/webapp.ini
INFO : server          initialised in ${jetty.base}/start.d/server.ini
INFO : websocket       initialised in ${jetty.base}/start.d/websocket.ini
INFO : client          initialised in ${jetty.base}/start.d/client.ini
INFO : Base directory was modified
[mybase]$ cd start.d/
[mybase]$ ls -all
total 32
drwxr-xr-x  6 staff  staff   204 Aug 29 15:19 .
drwxr-xr-x  3 staff  staff   102 Aug 29 15:16 ..
-rw-r--r--  1 staff  staff   175 Aug 29 15:19 client.ini
-rw-r--r--  1 staff  staff  2250 Aug 29 15:19 server.ini
-rw-r--r--  1 staff  staff   265 Aug 29 15:19 webapp.ini
-rw-r--r--  1 staff  staff   177 Aug 29 15:19 websocket.ini

In the example, we first create a new ${jetty.base} and then create the start.d directory with the --create-startd command. Next, we use the --add-to-start command which activates the modules and creates their respective ini files in the start.d directory.

If you have an existing start.ini file but would like to use the start.d structure for additional modules, you can use the --create-startd command as well. Doing this will create the start.d directory and copy your existing start.ini file in to it. Any new modules added to the server will have their own <module name>.ini file created in the start.d directory.

[mybase]$ java -jar ../start.jar --add-to-start=server,client,webapp,websocket
INFO : webapp          initialised in ${jetty.base}/start.ini
INFO : server          initialised in ${jetty.base}/start.ini
INFO : websocket       initialised in ${jetty.base}/start.ini
INFO : client          initialised in ${jetty.base}/start.ini
INFO : Base directory was modified

[mybase]$ java -jar ../start.jar --create-startd
INFO : Base directory was modified
[mybase]$ tree
.
└── start.d
    └── start.ini

[mybase]$ java -jar ../start.jar --add-to-start=ssl
INFO : ssl             initialised in ${jetty.base}/start.d/ssl.ini
INFO : Base directory was modified
[mybase]$ tree
.
├── etc
│   └── keystore
└── start.d
    ├── ssl.ini
    └── start.ini

Note

It is not recommended to use both a ${jetty.base}/start.ini file and a ${jetty.base}/start.d directory at the same time and doing so can cause issues.

Configuring Modules

Once a module has been enabled for the server, it can be further configured to meet your needs. This is done by editing the associated ini file for the module. If your server setup is using a centralized ini configuration, you will edit the ${jetty.base}/server.ini file. If you have elected to manage each module within it’s own ini file, you can find these files in the ${jetty.base}/start.d directory.

When a module is activated, a number of properties are set by default. To view these defaults, open up the associated ini file. Listed in the ini file is the associated module file and any properties that can be set.

Below is an example of the requestlog.ini file:

# ---------------------------------------
# Module: requestlog
--module=requestlog

## Logging directory (relative to $jetty.base)
# jetty.requestlog.dir=logs

## File path
# jetty.requestlog.filePath=${jetty.requestlog.dir}/yyyy_mm_dd.request.log

## Date format for rollovered files (uses SimpleDateFormat syntax)
# jetty.requestlog.filenameDateFormat=yyyy_MM_dd

## How many days to retain old log files
# jetty.requestlog.retainDays=90

## Whether to append to existing file
# jetty.requestlog.append=true

## Whether to use the extended log output
# jetty.requestlog.extended=true

## Whether to log http cookie information
# jetty.requestlog.cookies=true

## Timezone of the log entries
# jetty.requestlog.timezone=GMT

## Whether to log LogLatency
# jetty.requestlog.loglatency=false

The first lines name the module file being called (located in {$jetty.home/modules}). Subsequent lines list properties that can be changed as well as a description for each property. To edit a property, first un-comment the line by deleting the # at the start of the line, then make the change after = sign (such as changing a true value to false).

Disabling Modules

Disabling a module is an easy process. To disable a module, comment out the --module= line in the associated ini file. Deleting the ini file associated with module is another option, but may not be practical in all situations.

Listing Available and Active Modules

To see which modules are available, use the --list-modules command line argument. This command will also show you which modules are enabled. Here’s an example:

[mybase]$ java -jar ../start.jar --list-modules

Jetty All Available Modules:
----------------------------

 [ ] Module: alpn
           : Enables the ALPN extension to TLS(SSL) by adding modified classes to
           : the JVM bootpath.
           : This modification has a tight dependency on specific recent updates of
           : Java 1.7 and Java 1.8 (Java versions prior to 1.7u40 are not supported).
           : The alpn module will use an appropriate alpn-boot jar for your
           : specific version of Java.
     Depend: alpn-impl/alpn-${java.version}
     Depend: ssl
        LIB: lib/jetty-alpn-client-${jetty.version}.jar
        LIB: lib/jetty-alpn-server-${jetty.version}.jar
        XML: etc/jetty-alpn.xml

 [ ] Module: annotations
           : Enables Annotation scanning for deployed webapplications.
     Depend: plus
        LIB: lib/jetty-annotations-${jetty.version}.jar
        LIB: lib/annotations/*.jar
        XML: etc/jetty-annotations.xml

 [ ] Module: apache-jsp
           : Enables use of the apache implementation of JSP
        LIB: lib/apache-jsp/*.jar

 [ ] Module: apache-jstl
           : Enables the apache version of JSTL
        LIB: lib/apache-jstl/*.jar

 [ ] Module: cdi
           : Experimental CDI/Weld integration
     Depend: jsp
     Depend: annotations
     Depend: plus
     Depend: deploy
        LIB: lib/cdi/*.jar
        LIB: lib/cdi-core-${jetty.version}.jar
        LIB: lib/cdi-servlet-${jetty.version}.jar
        XML: etc/jetty-cdi.xml

 [ ] Module: client
           : Adds the Jetty HTTP client to the server classpath.
        LIB: lib/jetty-client-${jetty.version}.jar

 [ ] Module: continuation
           : Enables support for Continuation style asynchronous
           : Servlets.  Now deprecated in favour of Servlet 3.1
           : API
        LIB: lib/jetty-continuation-${jetty.version}.jar

 [ ] Module: debug
           : Enables the DebugListener to generate additional
           : logging regarding detailed request handling events.
           : Renames threads to include request URI.
     Depend: deploy
        XML: etc/jetty-debug.xml

 [ ] Module: debuglog
           : Deprecated Debug Log using the DebugHandle.
           : Replaced with the debug module.
     Depend: server
        XML: etc/jetty-debuglog.xml

 [x] Module: deploy
           : Enables webapplication deployment from the webapps directory.
     Depend: webapp
        LIB: lib/jetty-deploy-${jetty.version}.jar
        XML: etc/jetty-deploy.xml
    Enabled: ${jetty.base}/start.d/deploy.ini

 [ ] Module: ext
           : Adds all jar files discovered in $JETTY_HOME/lib/ext
           : and $JETTY_BASE/lib/ext to the servers classpath.
        LIB: lib/ext/**.jar

 [ ] Module: fcgi
           : Adds the FastCGI implementation to the classpath.
     Depend: servlet
     Depend: client
        LIB: lib/jetty-proxy-${jetty.version}.jar
        LIB: lib/fcgi/*.jar

 [ ] Module: gzip
           : Enable GzipHandler for dynamic gzip compression
           : for the entire server.
     Depend: server
        XML: etc/jetty-gzip.xml

 [ ] Module: hawtio
           : Deploys the Hawtio console as a webapplication.
     Depend: jmx
     Depend: stats
     Depend: deploy
        XML: etc/hawtio.xml

 [ ] Module: home-base-warning
           : Generates a warning that server has been run from $JETTY_HOME
           : rather than from a $JETTY_BASE.
        XML: etc/home-base-warning.xml

 [x] Module: http
           : Enables a HTTP connector on the server.
           : By default HTTP/1 is support, but HTTP2C can
           : be added to the connector with the http2c module.
     Depend: server
        XML: etc/jetty-http.xml
    Enabled: ${jetty.base}/start.d/http.ini

 [ ] Module: http-forwarded
           : Adds a forwarded request customizer to the HTTP Connector
           : to process forwarded-for style headers from a proxy.
     Depend: http
        XML: etc/jetty-http-forwarded.xml

 [ ] Module: http2
           : Enables HTTP2 protocol support on the TLS(SSL) Connector,
           : using the ALPN extension to select which protocol to use.
     Depend: alpn
     Depend: ssl
        LIB: lib/http2/*.jar
        XML: etc/jetty-http2.xml

 [ ] Module: http2c
           : Enables the HTTP2C protocol on the HTTP Connector
           : The connector will accept both HTTP/1 and HTTP/2 connections.
     Depend: http
        LIB: lib/http2/*.jar
        XML: etc/jetty-http2c.xml

 [ ] Module: https
           : Adds HTTPS protocol support to the TLS(SSL) Connector
     Depend: ssl
   Optional: http-forwarded
   Optional: http2
        XML: etc/jetty-https.xml

 [ ] Module: ipaccess
           : Enable the ipaccess handler to apply a white/black list
           : control of the remote IP of requests.
     Depend: server
        XML: etc/jetty-ipaccess.xml

 [ ] Module: jaas
           : Enable JAAS for deployed webapplications.
     Depend: server
        LIB: lib/jetty-jaas-${jetty.version}.jar
        XML: etc/jetty-jaas.xml

 [ ] Module: jamon
           : Deploys the JAMon webapplication
     Depend: jmx
     Depend: stats
     Depend: jsp
     Depend: deploy
        LIB: lib/jamon/**.jar
        XML: etc/jamon.xml

 [ ] Module: jaspi
           : Enable JASPI authentication for deployed webapplications.
     Depend: security
        LIB: lib/jetty-jaspi-${jetty.version}.jar
        LIB: lib/jaspi/*.jar

 [ ] Module: jcl
   Provides: [jcl, jcl-impl, jcl-api]
           : Provides a Java Commons Logging implementation.
           : To receive jetty logs the jetty-slf4j and slf4j-jcl must also be enabled.
        LIB: lib/jcl/commons-logging-${jcl.version}.jar

 [ ] Module: jcl-slf4j
   Provides: [jcl-slf4j, jcl-impl, jcl-api]
           : Provides a Java Commons Logging implementation that logs to the SLF4J API.
           : Requires another module that provides and SLF4J implementation.
     Depend: slf4j-api
        LIB: lib/slf4j/jcl-over-slf4j-${slf4j.version}.jar

 [ ] Module: jetty-jul
   Provides: [jetty-jul, logging]
           : Provides a Jetty Logging implementation that logs to the Java Util Logging API.
           : Requires another module that provides a Java Util Logging implementation.
        JVM: -Dorg.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.JavaUtilLog

 [ ] Module: jetty-log4j
           : Provides a Jetty Logging implementation that logs to the log4j API.
           : Uses the slf4j mechanism as an intermediary
           : Requires another module that provides an log4j implementation.
     Depend: jetty-slf4j
     Depend: slf4j-log4j

 [ ] Module: jetty-log4j2
           : Provides a Jetty Logging implementation that logs to the log4j API.
           : Uses the slf4j and log4j v1.2 mechanisms as intermediaries.
           : Requires another module that provides an log4j2 implementation.
     Depend: slf4j-log4j2
     Depend: jetty-slf4j

 [ ] Module: jetty-logback
           : Provides a Jetty Logging implementation that logs to logback.
           : Uses the slf4j API as an intermediary
     Depend: slf4j-logback
     Depend: jetty-slf4j

 [ ] Module: jetty-logging
   Provides: [jetty-logging, logging]
           : Enables the Jetty Logging implementation and installs a template
           : configuration in ${jetty.base} resources/jetty-logging.properties.
     Depend: resources

 [ ] Module: jetty-slf4j
   Provides: [logging, jetty-slf4j]
           : Provides a Jetty Logging implementation that logs to the SLF4J API.
           : Requires another module that provides and SLF4J implementation.
     Depend: slf4j-api
     Depend: slf4j-impl
        JVM: -Dorg.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.Slf4jLog

 [ ] Module: jminix
           : Deploys the Jminix JMX Console within the server
     Depend: jmx
     Depend: stats
     Depend: jcl-impl
     Depend: jcl-api
        LIB: lib/jminix/**.jar
        XML: etc/jminix.xml

 [ ] Module: jmx
           : Enables JMX instrumentation for server beans and
           : enables JMX agent.
     Depend: server
        LIB: lib/jetty-jmx-${jetty.version}.jar
        XML: etc/jetty-jmx.xml

 [ ] Module: jmx-remote
           : Enables remote RMI access to JMX
     Depend: jmx
        XML: etc/jetty-jmx-remote.xml

 [ ] Module: jndi
           : Adds the Jetty JNDI implementation to the classpath.
     Depend: server
        LIB: lib/jetty-jndi-${jetty.version}.jar
        LIB: lib/jndi/*.jar

 [ ] Module: jolokia
           : Deploys the Jolokia console as a web application.
     Depend: jmx
     Depend: stats
     Depend: deploy
        XML: etc/jolokia.xml

 [ ] Module: jsp
           : Enables JSP for all webapplications deployed on the server.
     Depend: apache-jsp
     Depend: servlet
     Depend: annotations

 [ ] Module: jstl
           : Enables JSTL for all webapplications deployed on the server
     Depend: jsp
     Depend: apache-jstl

 [ ] Module: jvm
           : A noop module that creates an ini template useful for
           : setting JVM arguments (eg -Xmx )

 [ ] Module: log4j
   Provides: [log4j-impl, log4j-api, log4j]
           : Provides a Log4j v1.2 API and implementation.
           : To receive jetty logs enable the jetty-slf4j and slf4j-log4j modules.
     Depend: resources
        LIB: lib/log4j/log4j-${log4j.version}.jar

 [ ] Module: log4j-log4j2
   Provides: [log4j-log4j2, log4j-impl, log4j-api]
           : Provides a Log4j v1.2 implementation that logs to the Log4j v2 API.
           : Requires another module that provides and Log4j v2 implementation.
           : To receive jetty logs the jetty-slf4j and slf4j-log4j must also be enabled.
     Depend: log4j2-api
     Depend: log4j2-impl
        LIB: lib/log4j/log4j-1.2-api-${log4j2.version}.jar

 [ ] Module: log4j2-api
           : Provides the Log4j v2 API
           : Requires another module that provides an Log4j v2 implementation.
           : To receive jetty logs enable the jetty-slf4j, slf4j-log4j and log4j-log4j2 modules.
        LIB: lib/log4j/log4j-api-${log4j2.version}.jar

 [ ] Module: log4j2-core
   Provides: [log4j2-core, log4j2-impl]
           : Provides a Log4j v2 implementation.
           : To receive jetty logs enable the jetty-slf4j, slf4j-log4j and log4j-log4j2 modules.
     Depend: log4j2-api
     Depend: resources
        LIB: lib/log4j/log4j-core-${log4j2.version}.jar

 [ ] Module: log4j2-slf4j
   Provides: [log4j2-slf4j, log4j2-impl]
           : Provides a Log4j v2 implementation that logs to the SLF4J API.
           : Requires another module that provides and SLF4J implementation.
           : To receive jetty logs enable the jetty-slf4j module.
     Depend: slf4j-api
     Depend: log4j2-api
        LIB: lib/log4j/log4j-slf4j-to-${log4j2.version}.jar

 [ ] Module: logback-access
   Provides: [requestlog, logback-access]
           : Enables logback request log.
     Depend: server
     Depend: logback-core
     Depend: resources
        LIB: lib/logback/logback-access-${logback.version}.jar
        XML: etc/jetty-logback-access.xml

 [ ] Module: logback-core
           : Provides the logback core implementation, used by slf4j-logback
           : and logback-access
        LIB: lib/logback/logback-core-${logback.version}.jar

 [ ] Module: lowresources
           : Enables a low resource monitor on the server
           : that can take actions if threads and/or connections
           : cross configured threshholds.
     Depend: server
        XML: etc/jetty-lowresources.xml

 [ ] Module: monitor
           : Enables the Jetty Monitor Module to periodically
           : check/publish JMX parameters of the server.
     Depend: server
     Depend: client
        LIB: lib/monitor/jetty-monitor-${jetty.version}.jar
        XML: etc/jetty-monitor.xml

 [ ] Module: plus
           : Enables JNDI and resource injection for webapplications
           : and other servlet 3.x features not supported in the core
           : jetty webapps module.
     Depend: webapp
     Depend: server
     Depend: security
     Depend: jndi
        LIB: lib/jetty-plus-${jetty.version}.jar
        XML: etc/jetty-plus.xml

 [ ] Module: proxy
           : Enable the Jetty Proxy, that allows the server to act
           : as a non-transparent proxy for browsers.
     Depend: servlet
     Depend: client
        LIB: lib/jetty-proxy-${jetty.version}.jar
        XML: etc/jetty-proxy.xml

 [ ] Module: proxy-protocol
           : Enables the Proxy Protocol on the HTTP Connector.
           : http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt
           : This allows a proxy operating in TCP mode to
           : transport details of the proxied connection to
           : the server.
           : Both V1 and V2 versions of the protocol are supported.
     Depend: http
        XML: etc/jetty-proxy-protocol.xml

 [ ] Module: proxy-protocol-ssl
           : Enables the Proxy Protocol on the TLS(SSL) Connector.
           : http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt
           : This allows a Proxy operating in TCP mode to transport
           : details of the proxied connection to the server.
           : Both V1 and V2 versions of the protocol are supported.
     Depend: ssl
        XML: etc/jetty-proxy-protocol-ssl.xml

 [ ] Module: quickstart
           : Enables the Jetty Quickstart module for rapid
           : deployment of preconfigured webapplications.
     Depend: server
     Depend: annotations
     Depend: plus
        LIB: lib/jetty-quickstart-${jetty.version}.jar

 [ ] Module: requestlog
           : Enables a NCSA style request log.
     Depend: server
        XML: etc/jetty-requestlog.xml

 [ ] Module: resources
           : Adds the $JETTY_HOME/resources and/or $JETTY_BASE/resources
           : directory to the server classpath. Useful for configuration
           : property files (eg jetty-logging.properties)
        LIB: resources/

 [ ] Module: rewrite
           : Enables the jetty-rewrite handler.  Specific rewrite
           : rules must be added to either to etc/jetty-rewrite.xml or a custom xml/module
     Depend: server
        LIB: lib/jetty-rewrite-${jetty.version}.jar
        XML: etc/jetty-rewrite.xml

 [ ] Module: rewrite-compactpath
           : Add a rule to the rewrite module to compact paths so that double slashes
           : in the path are treated as a single slash.
     Depend: rewrite
        XML: etc/rewrite-compactpath.xml

 [ ] Module: rewrite-customizer
   Provides: [rewrite-customizer, rewrite]
           : Enables a rewrite Rules container as a request customizer on
           : the servers default HttpConfiguration instance
     Depend: server
        LIB: lib/jetty-rewrite-${jetty.version}.jar
        XML: etc/jetty-rewrite-customizer.xml

 [t] Module: security
           : Adds servlet standard security handling to the classpath.
     Depend: server
        LIB: lib/jetty-security-${jetty.version}.jar
    Enabled: default provider of security for webapp
    Enabled: transitive provider of security for webapp

 [x] Module: server
           : Enables the core Jetty server on the classpath.
   Optional: jvm
   Optional: ext
   Optional: resources
   Optional: logging
        LIB: lib/servlet-api-3.1.jar
        LIB: lib/jetty-schemas-3.1.jar
        LIB: lib/jetty-http-${jetty.version}.jar
        LIB: lib/jetty-server-${jetty.version}.jar
        LIB: lib/jetty-xml-${jetty.version}.jar
        LIB: lib/jetty-util-${jetty.version}.jar
        LIB: lib/jetty-io-${jetty.version}.jar
        XML: etc/jetty.xml
    Enabled: ${jetty.base}/start.d/server.ini

 [t] Module: servlet
           : Enables standard Servlet handling.
     Depend: server
        LIB: lib/jetty-servlet-${jetty.version}.jar
    Enabled: transitive provider of servlet for webapp
    Enabled: default provider of servlet for webapp

 [ ] Module: servlets
           : Puts a collection of jetty utility servlets and filters
           : on the server classpath (CGI, CrossOriginFilter, DosFilter,
           : MultiPartFilter, PushCacheFilter, QoSFilter, etc.) for
           : use by all webapplications.
     Depend: servlet
        LIB: lib/jetty-servlets-${jetty.version}.jar

 [ ] Module: session-cache-hash
   Provides: [session-cache, session-cache-hash]
           : Enable first level session cache in ConcurrentHashMap.
           : If not enabled, sessions will use a HashSessionCache by default, so enabling
           : via this module is only needed if the configuration properties need to be
           : changed.
     Depend: sessions
        XML: etc/sessions/hash-session-cache.xml

 [ ] Module: session-store-cache
           : Enables caching of SessionData in front of a SessionDataStore.
     Depend: session-store
     Depend: sessions/session-data-cache/${session-data-cache}
        XML: etc/sessions/session-data-cache/session-caching-store.xml

 [ ] Module: session-store-file
   Provides: [session-store, session-store-file]
           : Enables session persistent storage in files.
     Depend: sessions
        XML: etc/sessions/file/session-store.xml

 [ ] Module: session-store-gcloud
   Provides: [session-store-gcloud, session-store]
           : Enables GCloudDatastore session management.
     Depend: webapp
     Depend: sessions
     Depend: jcl-impl
     Depend: annotations
     Depend: jcl-api
        LIB: lib/jetty-gcloud-session-manager-${jetty.version}.jar
        LIB: lib/gcloud/*.jar
        XML: etc/sessions/gcloud/session-store.xml

 [ ] Module: session-store-infinispan
   Provides: [session-store, session-store-infinispan]
           : Enables session data store in an Infinispan cache
     Depend: sessions
     Depend: sessions/infinispan/${cache-type}
        LIB: lib/jetty-infinispan-${jetty.version}.jar
        LIB: lib/infinispan/*.jar

 [ ] Module: session-store-jdbc
   Provides: [session-store, session-store-jdbc]
           : Enables JDBC peristent/distributed session storage.
     Depend: sessions
     Depend: sessions/jdbc/${db-connection-type}
        XML: etc/sessions/jdbc/session-store.xml

 [ ] Module: session-store-mongo
   Provides: [session-store-mongo, session-store]
           : Enables NoSql session management with a MongoDB driver.
     Depend: sessions
        LIB: lib/jetty-nosql-${jetty.version}.jar
        LIB: lib/nosql/*.jar
        XML: etc/sessions/mongo/session-store.xml

 [ ] Module: sessions
           : The session management. By enabling this module, it allows
           : session management to be configured via the ini templates
           : created or by enabling other session-cache or session-store
           : modules.  Without this module enabled, the server may still
           : use sessions, but their management cannot be configured.
     Depend: server
        XML: etc/sessions/id-manager.xml

 [ ] Module: setuid
           : Enables the unix setUID configuration so that the server
           : may be started as root to open privileged ports/files before
           : changing to a restricted user (eg jetty).
     Depend: server
        LIB: lib/setuid/jetty-setuid-java-1.0.3.jar
        XML: etc/jetty-setuid.xml

 [ ] Module: slf4j-api
           : Provides SLF4J API.  Requires a slf4j implementation (eg slf4j-simple)
           : otherwise a noop implementation is used.
        LIB: lib/slf4j/slf4j-api-${slf4j.version}.jar

 [ ] Module: slf4j-jcl
   Provides: [slf4j-jcl, slf4j-impl]
           : Provides a SLF4J implementation that logs to the Java Commons Logging API.
           : Requires another module that provides an JCL implementation.
           : To receive jetty logs enable the jetty-slf4j module.
     Depend: slf4j-api
     Depend: jcl-api
        LIB: lib/slf4j/slf4j-jcl-${slf4j.version}.jar

 [ ] Module: slf4j-jul
   Provides: [slf4j-jul, slf4j-impl]
           : Provides a SLF4J implementation that logs to the Java Util Logging API.
           : To receive jetty logs enable the jetty-slf4j module.
     Depend: slf4j-api
        LIB: lib/slf4j/slf4j-jdk14-${slf4j.version}.jar

 [ ] Module: slf4j-log4j
   Provides: [slf4j-log4j, slf4j-impl]
           : Provides a SLF4J implementation that logs to the Log4j v1.2 API.
           : Requires another module that provides a Log4j implementation.
           : To receive jetty logs enable the jetty-slf4j module.
     Depend: slf4j-api
     Depend: log4j-api
        LIB: lib/slf4j/slf4j-log4j12-${slf4j.version}.jar

 [ ] Module: slf4j-log4j2
   Provides: [slf4j-log4j2, slf4j-impl]
           : Provides a SLF4J implementation that logs to the Log4j v2 API.
           : Requires another module that provides a Log4j2 implementation.
           : To receive jetty logs enable the jetty-slf4j2 module.
     Depend: slf4j-api
     Depend: log4j2-api
        LIB: lib/log4j/log4j-slf4j-impl-${log4j2.version}.jar

 [ ] Module: slf4j-logback
   Provides: [slf4j-logback, slf4j-impl]
           : Provides a SLF4J implementation that logs to Logback classic
           : To receive jetty logs enable the jetty-slf4j module.
     Depend: slf4j-api
     Depend: logback-core
     Depend: resources
        LIB: lib/logback/logback-classic-${logback.version}.jar

 [ ] Module: slf4j-simple
   Provides: [slf4j-simple, slf4j-impl]
           : Provides SLF4J simple logging implementation.
           : To receive jetty logs enable the jetty-slf4j module.
     Depend: slf4j-api
        LIB: lib/slf4j/slf4j-simple-${slf4j.version}.jar

 [ ] Module: spring
           : Enable spring configuration processing so all jetty style
           : xml files can optionally be written as spring beans
     Depend: server
        LIB: lib/spring/*.jar

 [ ] Module: ssl
           : Enables a TLS(SSL) Connector on the server.
           : This may be used for HTTPS and/or HTTP2 by enabling
           : the associated support modules.
     Depend: server
        XML: etc/jetty-ssl.xml
        XML: etc/jetty-ssl-context.xml

 [ ] Module: stats
           : Enable detailed statistics collection for the server,
           : available via JMX.
     Depend: server
        XML: etc/jetty-stats.xml

 [ ] Module: stderrout-logging
           : Redirects JVMs stderr and stdout to a log file,
           : including output from Jetty's default StdErrLog logging.
        LIB: lib/logging/**.jar
        LIB: resources/
        XML: etc/stderrout-logging.xml

 [ ] Module: unixsocket
           : Enables a Unix Domain Socket Connector that can receive
           : requests from a local proxy and/or SSL offloader (eg haproxy) in either
           : HTTP or TCP mode.  Unix Domain Sockets are more efficient than
           : localhost TCP/IP connections  as they reduce data copies, avoid
           : needless fragmentation and have better dispatch behaviours.
           : When enabled with corresponding support modules, the connector can
           : accept HTTP, HTTPS or HTTP2C traffic.
     Depend: server
        LIB: lib/jetty-unixsocket-${jetty.version}.jar
        LIB: lib/jnr/*.jar
        XML: etc/jetty-unixsocket.xml

 [ ] Module: unixsocket-forwarded
           : Adds a forwarded request customizer to the HTTP configuration used
           : by the Unix Domain Socket connector, for use when behind a proxy operating
           : in HTTP mode that adds forwarded-for style HTTP headers. Typically this
           : is an alternate to the Proxy Protocol used mostly for TCP mode.
     Depend: unixsocket-http
        XML: etc/jetty-unixsocket-forwarded.xml

 [ ] Module: unixsocket-http
           : Adds a HTTP protocol support to the Unix Domain Socket connector.
           : It should be used when a proxy is forwarding either HTTP or decrypted
           : HTTPS traffic to the connector and may be used with the
           : unix-socket-http2c modules to upgrade to HTTP/2.
     Depend: unixsocket
        XML: etc/jetty-unixsocket-http.xml

 [ ] Module: unixsocket-http2c
           : Adds a HTTP2C connetion factory to the Unix Domain Socket Connector
           : It can be used when either the proxy forwards direct
           : HTTP/2C (unecrypted) or decrypted HTTP/2 traffic.
     Depend: unixsocket-http
        LIB: lib/http2/*.jar
        XML: etc/jetty-unixsocket-http2c.xml

 [ ] Module: unixsocket-proxy-protocol
           : Enables the proxy protocol on the Unix Domain Socket Connector
           : http://www.haproxy.org/download/1.5/doc/proxy-protocol.txt
           : This allows information about the proxied connection to be
           : efficiently forwarded as the connection is accepted.
           : Both V1 and V2 versions of the protocol are supported and any
           : SSL properties may be interpreted by the unixsocket-secure
           : module to indicate secure HTTPS traffic. Typically this
           : is an alternate to the forwarded module.
     Depend: unixsocket
        XML: etc/jetty-unixsocket-proxy-protocol.xml

 [ ] Module: unixsocket-secure
           : Enable a secure request customizer on the HTTP Configuration
           : used by the Unix Domain Socket Connector.
           : This looks for a secure scheme transported either by the
           : unixsocket-forwarded, unixsocket-proxy-protocol or in a
           : HTTP2 request.
     Depend: unixsocket-http
        XML: etc/jetty-unixsocket-secure.xml

 [x] Module: webapp
           : Adds support for servlet specification webapplication to the server
           : classpath.  Without this, only Jetty specific handlers may be deployed.
     Depend: security
     Depend: servlet
        LIB: lib/jetty-webapp-${jetty.version}.jar
    Enabled: ${jetty.base}/start.d/webapp.ini

 [ ] Module: websocket
           : Enable websockets for deployed web applications
     Depend: annotations
        LIB: lib/websocket/*.jar

Jetty Selected Module Ordering:
-------------------------------
    0) server          ${jetty.base}/start.d/server.ini
    1) security        default provider of security for webapp
                       transitive provider of security for webapp
    2) servlet         transitive provider of servlet for webapp
                       default provider of servlet for webapp
    3) webapp          ${jetty.base}/start.d/webapp.ini
    4) deploy          ${jetty.base}/start.d/deploy.ini
    5) http            ${jetty.base}/start.d/http.ini

Since being introduced in Jetty 9.1 the modules provided in the Jetty distribution has expanded greatly. Below is a graphical representation of the standard modules and their dependencies.

image

See an error or something missing? Contribute to this documentation at Github!(Generated: 2016-09-15)