Apache Tomcat - Embedded Servlet Container Configuration

Note that by default, the embedded container attempts to enable the HTTP2 protocol.

<dependency>
    <groupId>org.apereo.cas</groupId>
    <artifactId>cas-server-webapp-tomcat</artifactId>
    <version>${cas.version}</version>
</dependency>

implementation "org.apereo.cas:cas-server-webapp-tomcat:${project.'cas.version'}"

dependencyManagement {
    imports {
        mavenBom "org.apereo.cas:cas-server-support-bom:${project.'cas.version'}"
    }
}

dependencies {
    implementation "org.apereo.cas:cas-server-webapp-tomcat"
}

dependencies {
    /*
    The following platform references should be included automatically and are listed here for reference only.
            
    implementation enforcedPlatform("org.apereo.cas:cas-server-support-bom:${project.'cas.version'}")
    implementation platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES)
    */

    implementation "org.apereo.cas:cas-server-webapp-tomcat"
}

Configuration

The following settings and properties are available from the CAS configuration catalog:

_{The configuration settings listed below are tagged as Required in the CAS configuration metadata. This flag indicates that the presence of the setting may be needed to activate or affect the behavior of the CAS feature and generally should be reviewed, possibly owned and adjusted. If the setting is assigned a default value, you do not need to strictly put the setting in your copy of the configuration, but should review it nonetheless to make sure it matches your deployment expectations.}

_{The configuration settings listed below are tagged as Optional in the CAS configuration metadata. This
flag indicates that the presence of the setting
is not immediately necessary in the end-user CAS configuration, because a default value is assigned or
the activation of the feature is not conditionally controlled by the setting value. In other words, you should only include this field in your
configuration if you need to modify the default value or if you need to turn on the feature controlled by the setting.}

_{The configuration settings listed below are tagged as Third Party in the CAS configuration metadata. This flag indicates that the configuration setting is not controlled, owned or managed by the CAS ecosystem, and affects functionality that is offered by a third-party library, such as Spring Boot or Spring Cloud to CAS. For additional info, you might have to visit the third-party source to find more details.}

server.tomcat.accept-count=100

Maximum queue length for incoming connection requests when all possible request processing threads are in use.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

When possible, properties should be stored in lower-case kebab format, such as cas.property-name=value. The only possible exception to this rule is when naming actuator endpoints; The name of the actuator endpoints (i.e. ssoSessions) MUST remain in camelCase mode.

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accept-count=100

This is the most common form of property configuration that is recognized by CAS, regardless of the actual property source, which might in fact be managed separately outside the CAS environment, by another system or cloud framework.

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accept-count: "100"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accept-count="100" -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory. Note the placement of the system property which must be specified before the CAS web application is launched.

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCEPT_COUNT="100"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accept-count="100"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.buffered=true

Whether to buffer output such that it is flushed only periodically.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.buffered=true

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      buffered: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.buffered="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_BUFFERED="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.buffered="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.check-exists=false

Whether to check for log file existence so it can be recreated if an external process has renamed it.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.check-exists=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      check-exists: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.check-exists="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_CHECK_EXISTS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.check-exists="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.condition-if=

Whether logging of the request will only be enabled if "ServletRequest.getAttribute(conditionIf)" does not yield null.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.condition-if=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      condition-if: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.condition-if="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_CONDITION_IF="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.condition-if="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.condition-unless=

Whether logging of the request will only be enabled if "ServletRequest.getAttribute(conditionUnless)" yield null.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.condition-unless=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      condition-unless: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.condition-unless="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_CONDITION_UNLESS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.condition-unless="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.directory=logs

Directory in which log files are created. Can be absolute or relative to the Tomcat base dir.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.directory=logs

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      directory: "logs"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.directory="logs" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_DIRECTORY="logs"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.directory="logs"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.enabled=false

Enable access log.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.enabled=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.encoding=

Character set used by the log file. Default to the system default character set.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.encoding=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      encoding: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.encoding="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_ENCODING="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.encoding="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.file-date-format=.yyyy-MM-dd

Date format to place in the log file name.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.file-date-format=.yyyy-MM-dd

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      file-date-format: ".yyyy-MM-dd"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.file-date-format=".yyyy-MM-dd" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_FILE_DATE_FORMAT=".yyyy-MM-dd"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.file-date-format=".yyyy-MM-dd"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.ipv6-canonical=false

Whether to use IPv6 canonical representation format as defined by RFC 5952.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.ipv6-canonical=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      ipv6-canonical: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.ipv6-canonical="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_IPV6_CANONICAL="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.ipv6-canonical="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.locale=

Locale used to format timestamps in log entries and in log file name suffix. Default to the default locale of the Java process.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.locale=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      locale: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.locale="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_LOCALE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.locale="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.max-days=-1

Number of days to retain the access log files before they are removed.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.max-days=-1

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      max-days: "-1"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.max-days="-1" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_MAX_DAYS="-1"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.max-days="-1"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.pattern=common

Format pattern for access logs.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.pattern=common

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      pattern: "common"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.pattern="common" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_PATTERN="common"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.pattern="common"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.prefix=access_log

Log file name prefix.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.prefix=access_log

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      prefix: "access_log"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.prefix="access_log" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_PREFIX="access_log"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.prefix="access_log"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.rename-on-rotate=false

Whether to defer inclusion of the date stamp in the file name until rotate time.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.rename-on-rotate=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      rename-on-rotate: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.rename-on-rotate="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_RENAME_ON_ROTATE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.rename-on-rotate="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.request-attributes-enabled=false

Set request attributes for the IP address, Hostname, protocol, and port used for the request.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.request-attributes-enabled=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      request-attributes-enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.request-attributes-enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_REQUEST_ATTRIBUTES_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.request-attributes-enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.rotate=true

Whether to enable access log rotation.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.rotate=true

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      rotate: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.rotate="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_ROTATE="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.rotate="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.accesslog.suffix=.log

Log file name suffix.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Accesslog.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.accesslog.suffix=.log

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    accesslog: 
      suffix: ".log"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.accesslog.suffix=".log" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ACCESSLOG_SUFFIX=".log"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.accesslog.suffix=".log"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.additional-tld-skip-patterns=

Comma-separated list of additional patterns that match jars to ignore for TLD scanning. The special '?' and '*' characters can be used in the pattern to match one and only one character and zero or more characters respectively.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.additional-tld-skip-patterns=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    additional-tld-skip-patterns: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.additional-tld-skip-patterns="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_ADDITIONAL_TLD_SKIP_PATTERNS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.additional-tld-skip-patterns="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.background-processor-delay=10s

Delay between the invocation of backgroundProcess methods. If a duration suffix is not specified, seconds will be used.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.background-processor-delay=10s

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    background-processor-delay: "10s"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.background-processor-delay="10s" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_BACKGROUND_PROCESSOR_DELAY="10s"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.background-processor-delay="10s"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.basedir=

Tomcat base directory. If not specified, a temporary directory is used.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.basedir=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    basedir: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.basedir="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_BASEDIR="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.basedir="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.connection-timeout=

Amount of time the connector will wait, after accepting a connection, for the request URI line to be presented.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.connection-timeout=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    connection-timeout: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.connection-timeout="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_CONNECTION_TIMEOUT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.connection-timeout="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.keep-alive-timeout=

Time to wait for another HTTP request before the connection is closed. When not set the connectionTimeout is used. When set to -1 there will be no timeout.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.keep-alive-timeout=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    keep-alive-timeout: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.keep-alive-timeout="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_KEEP_ALIVE_TIMEOUT="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.keep-alive-timeout="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.max-connections=8192

Maximum number of connections that the server accepts and processes at any given time. Once the limit has been reached, the operating system may still accept connections based on the "acceptCount" property.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.max-connections=8192

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    max-connections: "8192"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.max-connections="8192" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MAX_CONNECTIONS="8192"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.max-connections="8192"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.max-http-form-post-size=2MB

Maximum size of the form content in any HTTP post request.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.max-http-form-post-size=2MB

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    max-http-form-post-size: "2MB"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.max-http-form-post-size="2MB" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MAX_HTTP_FORM_POST_SIZE="2MB"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.max-http-form-post-size="2MB"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.max-http-post-size=

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.max-http-post-size=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    max-http-post-size: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.max-http-post-size="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MAX_HTTP_POST_SIZE="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.max-http-post-size="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

Deprecation status is ERRORwith a replacement setting: server.tomcat.max-http-form-post-size.

server.tomcat.max-http-response-header-size=8KB

Maximum size of the HTTP response header.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.max-http-response-header-size=8KB

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    max-http-response-header-size: "8KB"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.max-http-response-header-size="8KB" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MAX_HTTP_RESPONSE_HEADER_SIZE="8KB"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.max-http-response-header-size="8KB"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.max-keep-alive-requests=100

Maximum number of HTTP requests that can be pipelined before the connection is closed. When set to 0 or 1, keep-alive and pipelining are disabled. When set to -1, an unlimited number of pipelined or keep-alive requests are allowed.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.max-keep-alive-requests=100

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    max-keep-alive-requests: "100"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.max-keep-alive-requests="100" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MAX_KEEP_ALIVE_REQUESTS="100"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.max-keep-alive-requests="100"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.max-swallow-size=2MB

Maximum amount of request body to swallow.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.max-swallow-size=2MB

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    max-swallow-size: "2MB"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.max-swallow-size="2MB" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MAX_SWALLOW_SIZE="2MB"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.max-swallow-size="2MB"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.mbeanregistry.enabled=false

Whether Tomcat's MBean Registry should be enabled.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Mbeanregistry.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.mbeanregistry.enabled=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    mbeanregistry: 
      enabled: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.mbeanregistry.enabled="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_MBEANREGISTRY_ENABLED="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.mbeanregistry.enabled="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.processor-cache=200

Maximum number of idle processors that will be retained in the cache and reused with a subsequent request. When set to -1 the cache will be unlimited with a theoretical maximum size equal to the maximum number of connections.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.processor-cache=200

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    processor-cache: "200"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.processor-cache="200" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_PROCESSOR_CACHE="200"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.processor-cache="200"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.redirect-context-root=true

Whether requests to the context root should be redirected by appending a / to the path. When using SSL terminated at a proxy, this property should be set to false.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.redirect-context-root=true

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    redirect-context-root: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.redirect-context-root="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REDIRECT_CONTEXT_ROOT="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.redirect-context-root="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.reject-illegal-header=true

Whether to reject requests with illegal header names or values.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.reject-illegal-header=true

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    reject-illegal-header: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.reject-illegal-header="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REJECT_ILLEGAL_HEADER="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.reject-illegal-header="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

Deprecation status is WARNINGwithout a replacement setting.

server.tomcat.relaxed-path-chars=

Comma-separated list of additional unencoded characters that should be allowed in URI paths. Only "< > [ \ ] ^ ` { | }" are allowed.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.relaxed-path-chars=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    relaxed-path-chars: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.relaxed-path-chars="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_RELAXED_PATH_CHARS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.relaxed-path-chars="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.relaxed-query-chars=

Comma-separated list of additional unencoded characters that should be allowed in URI query strings. Only "< > [ \ ] ^ ` { | }" are allowed.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.relaxed-query-chars=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    relaxed-query-chars: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.relaxed-query-chars="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_RELAXED_QUERY_CHARS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.relaxed-query-chars="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.host-header=X-Forwarded-Host

Name of the HTTP header from which the remote host is extracted.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.host-header=X-Forwarded-Host

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      host-header: "X-Forwarded-Host"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.host-header="X-Forwarded-Host" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_HOST_HEADER="X-Forwarded-Host"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.host-header="X-Forwarded-Host"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.internal-proxies=10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1

Regular expression that matches proxies that are to be trusted.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.internal-proxies=10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      internal-proxies: "10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.internal-proxies="10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_INTERNAL_PROXIES="10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.internal-proxies="10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.port-header=X-Forwarded-Port

Name of the HTTP header used to override the original port value.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.port-header=X-Forwarded-Port

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      port-header: "X-Forwarded-Port"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.port-header="X-Forwarded-Port" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_PORT_HEADER="X-Forwarded-Port"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.port-header="X-Forwarded-Port"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.protocol-header=

Header that holds the incoming protocol, usually named "X-Forwarded-Proto".

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.protocol-header=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      protocol-header: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.protocol-header="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_PROTOCOL_HEADER="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.protocol-header="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.protocol-header-https-value=https

Value of the protocol header indicating whether the incoming request uses SSL.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.protocol-header-https-value=https

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      protocol-header-https-value: "https"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.protocol-header-https-value="https" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_PROTOCOL_HEADER_HTTPS_VALUE="https"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.protocol-header-https-value="https"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.remote-ip-header=

Name of the HTTP header from which the remote IP is extracted. For instance, 'X-FORWARDED-FOR'.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.remote-ip-header=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      remote-ip-header: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.remote-ip-header="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_REMOTE_IP_HEADER="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.remote-ip-header="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.remoteip.trusted-proxies=

Regular expression defining proxies that are trusted when they appear in the "remote-ip-header" header.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Remoteip.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.remoteip.trusted-proxies=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    remoteip: 
      trusted-proxies: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.remoteip.trusted-proxies="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_REMOTEIP_TRUSTED_PROXIES="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.remoteip.trusted-proxies="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.resource.allow-caching=true

Whether static resource caching is permitted for this web application.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Resource.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.resource.allow-caching=true

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    resource: 
      allow-caching: "true"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.resource.allow-caching="true" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_RESOURCE_ALLOW_CACHING="true"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.resource.allow-caching="true"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.resource.cache-ttl=

Time-to-live of the static resource cache.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Resource.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.resource.cache-ttl=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    resource: 
      cache-ttl: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.resource.cache-ttl="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_RESOURCE_CACHE_TTL="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.resource.cache-ttl="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.threads.max=200

Maximum amount of worker threads.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Threads.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.threads.max=200

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    threads: 
      max: "200"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.threads.max="200" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_THREADS_MAX="200"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.threads.max="200"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.threads.min-spare=10

Minimum amount of worker threads.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat$Threads.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.threads.min-spare=10

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    threads: 
      min-spare: "10"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.threads.min-spare="10" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_THREADS_MIN_SPARE="10"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.threads.min-spare="10"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.uri-encoding=UTF-8

Character encoding to use to decode the URI.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.uri-encoding=UTF-8

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    uri-encoding: "UTF-8"

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.uri-encoding="UTF-8" -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_URI_ENCODING="UTF-8"

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.uri-encoding="UTF-8"

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

server.tomcat.use-relative-redirects=false

Whether HTTP 1.1 and later location headers generated by a call to sendRedirect will use relative or absolute redirects.

org.springframework.boot.autoconfigure.web.ServerProperties$Tomcat.

_{How can I configure this property?}

Configuration properties can be included and activated using the following strategies.

Note

CAS properties can be specified using the Java configuration property syntax in any and all .properties files:

server.tomcat.use-relative-redirects=...

CAS properties can be specified using the YAML syntax:

server: 
  tomcat: 
    use-relative-redirects: "..."

Note that YAML is very specific about structure and indentation. Be sure to verify the correctness of the final result with your YAML validator of choice.

CAS properties can be passed to the CAS web application as system properties, when the application is launched:

java -Dserver.tomcat.use-relative-redirects="..." -jar build/libs/cas.war

CAS properties can specified as system environment variables before the CAS web application is launched:

export SERVER_TOMCAT_USE_RELATIVE_REDIRECTS="..."

java -jar build/libs/cas.war

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

CAS properties can be passed to the CAS web application as command-line arguments, when the application is launched:

java -jar build/libs/cas.war --server.tomcat.use-relative-redirects="..."

The above example assumes that the CAS web application is packaged as cas.war with an embedded server container and can be found in the build/libs directory.

# Maximum queue length for incoming connection requests when all possible request processing threads are in use.
# server.tomcat.accept-count=100

# Whether to buffer output such that it is flushed only periodically.
# server.tomcat.accesslog.buffered=true

# Whether to check for log file existence so it can be recreated if an external process has renamed it.
# server.tomcat.accesslog.check-exists=false

# Whether logging of the request will only be enabled if "ServletRequest.getAttribute(conditionIf)" does not yield null.
# server.tomcat.accesslog.condition-if=

# Whether logging of the request will only be enabled if "ServletRequest.getAttribute(conditionUnless)" yield null.
# server.tomcat.accesslog.condition-unless=

# Directory in which log files are created.
# server.tomcat.accesslog.directory=logs

# Enable access log.
# server.tomcat.accesslog.enabled=false

# Character set used by the log file.
# server.tomcat.accesslog.encoding=

# Date format to place in the log file name.
# server.tomcat.accesslog.file-date-format=.yyyy-MM-dd

# Whether to use IPv6 canonical representation format as defined by RFC 5952.
# server.tomcat.accesslog.ipv6-canonical=false

# Locale used to format timestamps in log entries and in log file name suffix.
# server.tomcat.accesslog.locale=

# Number of days to retain the access log files before they are removed.
# server.tomcat.accesslog.max-days=-1

# Format pattern for access logs.
# server.tomcat.accesslog.pattern=common

# Log file name prefix.
# server.tomcat.accesslog.prefix=access_log

# Whether to defer inclusion of the date stamp in the file name until rotate time.
# server.tomcat.accesslog.rename-on-rotate=false

# Set request attributes for the IP address, Hostname, protocol, and port used for the request.
# server.tomcat.accesslog.request-attributes-enabled=false

# Whether to enable access log rotation.
# server.tomcat.accesslog.rotate=true

# Log file name suffix.
# server.tomcat.accesslog.suffix=.log

# Comma-separated list of additional patterns that match jars to ignore for TLD scanning.
# server.tomcat.additional-tld-skip-patterns=

# Delay between the invocation of backgroundProcess methods.
# server.tomcat.background-processor-delay=10s

# Tomcat base directory.
# server.tomcat.basedir=

# Amount of time the connector will wait, after accepting a connection, for the request URI line to be presented.
# server.tomcat.connection-timeout=

# Time to wait for another HTTP request before the connection is closed.
# server.tomcat.keep-alive-timeout=

# Maximum number of connections that the server accepts and processes at any given time.
# server.tomcat.max-connections=8192

# Maximum size of the form content in any HTTP post request.
# server.tomcat.max-http-form-post-size=2MB

# 
# server.tomcat.max-http-post-size=

# Maximum size of the HTTP response header.
# server.tomcat.max-http-response-header-size=8KB

# Maximum number of HTTP requests that can be pipelined before the connection is closed.
# server.tomcat.max-keep-alive-requests=100

# Maximum amount of request body to swallow.
# server.tomcat.max-swallow-size=2MB

# Whether Tomcat's MBean Registry should be enabled.
# server.tomcat.mbeanregistry.enabled=false

# Maximum number of idle processors that will be retained in the cache and reused with a subsequent request.
# server.tomcat.processor-cache=200

# Whether requests to the context root should be redirected by appending a / to the path.
# server.tomcat.redirect-context-root=true

# Whether to reject requests with illegal header names or values.
# server.tomcat.reject-illegal-header=true

# Comma-separated list of additional unencoded characters that should be allowed in URI paths.
# server.tomcat.relaxed-path-chars=

# Comma-separated list of additional unencoded characters that should be allowed in URI query strings.
# server.tomcat.relaxed-query-chars=

# Name of the HTTP header from which the remote host is extracted.
# server.tomcat.remoteip.host-header=X-Forwarded-Host

# Regular expression that matches proxies that are to be trusted.
# server.tomcat.remoteip.internal-proxies=10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|100\.6[4-9]{1}\.\d{1,3}\.\d{1,3}|100\.[7-9]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.1[0-1]{1}\d{1}\.\d{1,3}\.\d{1,3}|100\.12[0-7]{1}\.\d{1,3}\.\d{1,3}|172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}|172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}|0:0:0:0:0:0:0:1|::1

# Name of the HTTP header used to override the original port value.
# server.tomcat.remoteip.port-header=X-Forwarded-Port

# Header that holds the incoming protocol, usually named "X-Forwarded-Proto".
# server.tomcat.remoteip.protocol-header=

# Value of the protocol header indicating whether the incoming request uses SSL.
# server.tomcat.remoteip.protocol-header-https-value=https

# Name of the HTTP header from which the remote IP is extracted.
# server.tomcat.remoteip.remote-ip-header=

# Regular expression defining proxies that are trusted when they appear in the "remote-ip-header" header.
# server.tomcat.remoteip.trusted-proxies=

# Whether static resource caching is permitted for this web application.
# server.tomcat.resource.allow-caching=true

# Time-to-live of the static resource cache.
# server.tomcat.resource.cache-ttl=

# Maximum amount of worker threads.
# server.tomcat.threads.max=200

# Minimum amount of worker threads.
# server.tomcat.threads.min-spare=10

# Character encoding to use to decode the URI.
# server.tomcat.uri-encoding=UTF-8

# Whether HTTP 1.1 and later location headers generated by a call to sendRedirect will use relative or absolute redirects.
# server.tomcat.use-relative-redirects=false

Configuration Metadata

The collection of configuration properties listed in this section are automatically generated from the CAS source and components that contain the actual field definitions, types, descriptions, modules, etc. This metadata may not always be 100% accurate, or could be lacking details and sufficient explanations.

Be Selective

This section is meant as a guide only. Do NOT copy/paste the entire collection of settings into your CAS configuration; rather pick only the properties that you need. Do NOT enable settings unless you are certain of their purpose and do NOT copy settings into your configuration only to keep them as reference. All these ideas lead to upgrade headaches, maintenance nightmares and premature aging.

YAGNI

Note that for nearly ALL use cases, declaring and configuring properties listed here is sufficient. You should NOT have to explicitly massage a CAS XML/Java/etc configuration file to design an authentication handler, create attribute release policies, etc. CAS at runtime will auto-configure all required changes for you. If you are unsure about the meaning of a given CAS setting, do NOT turn it on without hesitation. Review the codebase or better yet, ask questions to clarify the intended behavior.

Naming Convention

Property names can be specified in very relaxed terms. For instance cas.someProperty, cas.some-property, cas.some_property are all valid names. While all forms are accepted by CAS, there are certain components (in CAS and other frameworks used) whose activation at runtime is conditional on a property value, where this property is required to have been specified in CAS configuration using kebab case. This is both true for properties that are owned by CAS as well as those that might be presented to the system via an external library or framework such as Spring Boot, etc.

Note

Settings and properties that are controlled by the CAS platform directly always begin with the prefix cas. All other settings are controlled and provided to CAS via other underlying frameworks and may have their own schemas and syntax. BE CAREFUL with the distinction. Unrecognized properties are rejected by CAS and/or frameworks upon which CAS depends. This means if you somehow misspell a property definition or fail to adhere to the dot-notation syntax and such, your setting is entirely refused by CAS and likely the feature it controls will never be activated in the way you intend.

Validation

Configuration properties are automatically validated on CAS startup to report issues with configuration binding, specially if defined CAS settings cannot be recognized or validated by the configuration schema. Additional validation processes are also handled via Configuration Metadata and property migrations applied automatically on startup by Spring Boot and family.

Indexed Settings

CAS settings able to accept multiple values are typically documented with an index, such as cas.some.setting[0]=value. The index [0] is meant to be incremented by the adopter to allow for distinct multiple configuration blocks.

IPv4 Configuration

In order to force Apache Tomcat to use IPv4, configure the following as a system property for your run command:

-Djava.net.preferIPv4Stack=true 

The same sort of configuration needs to be applied to your $CATALINA_OPTS environment variable in case of an external container.