Thorntail is a framework based on the popular WildFly Java application server to enable the creation of small, standalone microservice-based applications. Thorntail is capable of producing so-called just enough app-server to support each component of your system.

For more information, see the Thorntail home page.

Concepts

1. Fractions

Thorntail is defined by an unbounded set of capabilities. Each piece of functionality is called a fraction. Some fractions provide only access to APIs, such as JAX-RS or CDI; other fractions provide higher-level capabilities, such as integration with RHSSO (Keycloak).

The typical method for consuming Thorntail fractions is through Maven coordinates, which you add to the pom.xml file in your application. The functionality the fraction provides is then packaged with your application (see Creating an uberjar).

To enable easier consumption of Thorntail fractions, a bill of materials (BOM) is available. For more information, see Using a BOM.

2. Packaging Types

When using Thorntail, there are the following ways to package your runtime and application, depending on how you intend to use and deploy it:

2.1. Uberjar

An uberjar is a single Java .jar file that includes everything you need to execute your application. This means both the runtime components you have selected—you can understand that as the app server—along with the application components (your .war file).

An uberjar is useful for many continuous integration and continuous deployment (CI/CD) pipeline styles, in which a single executable binary artifact is produced and moved through the testing, validation, and production environments in your organization.

The names of the uberjars that Thorntail produces include the name of your application and the -thorntail.jar suffix.

An uberjar can be executed like any executable JAR:

$ java -jar myapp-thorntail.jar

2.2. Hollow JAR

A hollow JAR is similar to an uberjar, but includes only the runtime components, and does not include your application code.

A hollow jar is suitable for deployment processes that involve Linux containers such as Docker. When using containers, place the runtime components in a container image lower in the image hierarchy—which means it changes less often—so that the higher layer which contains only your application code can be rebuilt more quickly.

The names of the hollow JARs that Thorntail produces include the name of your application, and the -hollow-thorntail.jar suffix. You must package the .war file of your application separately in order to benefit from the hollow JAR.

Note

Using hollow JARs has certain limitations:

To enable Thorntail to autodetect a JDBC driver, you must add the JAR with the driver to the thorntail.classpath system property, for example:
```
$ java -Dthorntail.classpath=./h2-1.4.196.jar -jar my-hollow-thorntail.jar myApp.war
```
YAML configuration files in your application are not automatically applied. You must specify them manually, for example:
```
$ java -jar my-hollow-thorntail.jar myApp.war -s ./project-defaults.yml
```

When executing the hollow JAR, provide the application .war file as an argument to the Java binary:

$ java -jar myapp-hollow-thorntail.jar myapp.war

2.2.1. Pre-Built Hollow JARs

Thorntail ships the following pre-built hollow JARs:

full: The main Java EE related capabilities
web: Functionality focused on web technologies
microprofile: Functionality defined by all Eclipse MicroProfile specifications

The hollow JARs are available under the following coordinates:

<dependency>
    <groupId>io.thorntail.servers</groupId>
    <artifactId>[full|web|microprofile]</artifactId>
</dependency>

HOWTO

3. Basics

3.1. Creating an application from scratch

Creating a simple Thorntail–based application with a REST endpoint from scratch.

Prerequisites

JDK 8 or newer installed
Maven 3.3.x or newer installed

Procedure

Create a directory for the application and navigate to it:
$ mkdir myApp $ cd myApp
We recommend you start tracking the directory contents with Git. For more information, see Git tutorial.

In the directory, create a pom.xml file with the following content.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>restful-endpoint</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>Thorntail Example</name>

  <properties>
    <version.thorntail>2.2.1.Final</version.thorntail>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <failOnMissingWebXml>false</failOnMissingWebXml>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.thorntail</groupId>
        <artifactId>bom</artifactId>
        <version>${version.thorntail}</version>
        <scope>import</scope>
        <type>pom</type>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>io.thorntail</groupId>
      <artifactId>jaxrs</artifactId>
    </dependency>
  </dependencies>

  <build>
    <finalName>restful-endpoint</finalName>
    <plugins>
      <plugin>
        <groupId>io.thorntail</groupId>
        <artifactId>thorntail-maven-plugin</artifactId>
        <version>${version.thorntail}</version>
        <executions>
          <execution>
            <goals>
              <goal>package</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>openshift</id>
      <build>
        <plugins>
          <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>fabric8-maven-plugin</artifactId>
            <executions>
              <execution>
                <goals>
                  <goal>resource</goal>
                  <goal>build</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>

Create a directory structure for your application:
```
mkdir -p src/main/java/com/example/rest
```

In the src/main/java/com/example/rest directory, create the source files:

HelloWorldEndpoint.java with the class that serves the HTTP endpoint:

package com.example.rest;

import javax.ws.rs.Path;
import javax.ws.rs.core.Response;
import javax.ws.rs.GET;
import javax.ws.rs.Produces;

@Path("/hello")
public class HelloWorldEndpoint {

  @GET
  @Produces("text/plain")
  public Response doGet() {
    return Response.ok("Hello from Thorntail!").build();
  }
}

RestApplication.java with the application context:

package com.example.rest;

import javax.ws.rs.core.Application;
import javax.ws.rs.ApplicationPath;

@ApplicationPath("/rest")
public class RestApplication extends Application {
}

Execute the application using Maven:
```
$ mvn thorntail:run
```

Results

Accessing the http://localhost:8080/rest/hello URL in your browser should return the following message:

Hello from Thorntail!

After finishing the procedure, there should be a directory on your hard drive with the following contents:

myApp
├── pom.xml
└── src
    └── main
        └── java
            └── com
                └── example
                    └── rest
                        ├── HelloWorldEndpoint.java
                        └── RestApplication.java

3.2. Using a BOM

To explicitly specify the Thorntail fractions your application uses, instead of relying on auto-detection, Thorntail includes a set of BOMs (bill of materials) which you can use instead of having to track and update Maven artifact versions in several places.

3.2.1. Thorntail community BOM types

Thorntail is described as just enough app-server, which means it consists of multiple pieces. Your application includes only the pieces it needs.

Over time, some of these pieces reach the stable status, while some are classified as unstable or experimental.

When using Thorntail, you can specify the following Maven BOMs:

bom-all: All fractions: stable, unstable, experimental, and even deprecated.
bom-deprecated: Fractions that have been deprecated.
bom-experimental: Fractions that are considered experimental, which means they can disappear or radically change between releases.
bom-unstable: Fractions that do not change as often as the experimental ones. However, unstable fractions can still change their behavior or contain bugs, even dangerous ones.
bom-stable or bom: Fractions recommended for daily use.

3.2.2. Specifying a BOM for in your application

Importing a specific BOM in the pom.xml file in your application allows you to track all your application dependencies in one place.

Note

One shortcoming of importing a Maven BOM import is that it does not handle the configuration on the level of <pluginManagement>. When you use the Thorntail Maven Plugin, you must specify the version of the plugin to use.

Thanks to the property you use in your pom.xml file, you can easily ensure that your plugin usage matches the release of Thorntail that you are targeting with the BOM import.

<plugins>
  <plugin>
    <groupId>io.thorntail</groupId>
    <artifactId>thorntail-maven-plugin</artifactId>
    <version>${version.thorntail}</version>
      ...
  </plugin>
</plugins>

Prerequisites

Your application as a Maven-based project with a pom.xml file.

Procedure

Include a bom artifact in your pom.xml.
Tracking the current version of Thorntail through a property in your pom.xml is recommended.
<properties> <version.thorntail>2.2.1.Final</version.thorntail> </properties>
Import BOMs in the <dependencyManagement> section. Specify the <type>pom</type> and <scope>import</scope>.
<dependencyManagement> <dependencies> <dependency> <groupId>io.thorntail</groupId> <artifactId>bom</artifactId> <version>${version.thorntail}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
In the example above, the bom artifact is imported to ensure that only stable fractions are available.

If you want to experiment with some unstable fractions in addition to the stable ones, uncomment the <dependency> for bom-unstable:
<dependencyManagement> <dependencies> <dependency> <groupId>io.thorntail</groupId> <artifactId>bom</artifactId> <version>${version.thorntail}</version> <type>pom</type> <scope>import</scope> </dependency>  </dependencies> </dependencyManagement>
Remember, each flavor of bom, with the exception of bom-all contains only the type of fractions indicated. This allows mixing and matching the combination of fraction stability that you want with fine granularity. If you want both stable and unstable, you would need to include both bom-stable (or bom) and bom-unstable.

By including the BOMs of your choice in the <dependencyManagement> section, you have:
- Provided version-management for any Thorntail artifacts you subsequently choose to use.
- Provided support to your IDE for auto-completing known artifacts when you edit your the pom.xml file of your application.
Include Thorntail dependencies.
Even though you imported the Thorntail BOMs in the <dependencyManagement> section, your application still has no dependencies on Thorntail artifacts.

To include Thorntail artifact dependencies based on the capabilities your application, enter the relevant artifacts as <dependency> elements:

Note
You do not have to specify the version of the artifacts because the BOM imported in <dependencyManagement> handles that.
<dependencies> <dependency> <groupId>io.thorntail</groupId> <artifactId>jaxrs</artifactId> </dependency> <dependency> <groupId>io.thorntail</groupId> <artifactId>datasources</artifactId> </dependency> </dependencies>
In the example above, we include explicit dependencies on the jaxrs and datasources fractions, which will provide transitive inclusion of others, for example undertow.

3.3. Creating an uberjar

One method of packaging an application for execution with Thorntail is as an uberjar.

Prerequisites

A Maven-based application with a pom.xml file.

Procedure

Add the thorntail-maven-plugin to your pom.xml in a <plugin> block, with an <execution> specifying the package goal.

<plugins>
  <plugin>
    <groupId>io.thorntail</groupId>
    <artifactId>thorntail-maven-plugin</artifactId>
    <version>${version.thorntail}</version>
    <executions>
      <execution>
        <id>package</id>
        <goals>
          <goal>package</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>

Perform a normal Maven build:
```
$ mvn package
```

Execute the resulting uberjar:

$ java -jar ./target/myapp-thorntail.jar

3.4. Creating a hollow JAR

The hollow JAR is one method of packaging an application for execution with Thorntail.

Prerequisites

A Maven-based application with a pom.xml file.

Procedure

Add the thorntail-maven-plugin to your pom.xml in a <plugin> block, with an <execution> specifying the package goal. In addition to that, put true in the hollow property of the <configuration> element:

<plugins>
  <plugin>
    <groupId>io.thorntail</groupId>
    <artifactId>thorntail-maven-plugin</artifactId>
    <version>${version.thorntail}</version>
    <executions>
      <execution>
        <id>package</id>
        <goals>
          <goal>package</goal>
        </goals>
        <configuration>
          <hollow>true</hollow>
        </configuration>
      </execution>
    </executions>
  </plugin>
</plugins>

You can also execute the Maven binary with the system property -Dthorntail.hollow=true instead. For more information, see the Maven plugin configuration reference.

Perform a normal Maven build:
```
$ mvn package
```
Execute the hollow JAR:

Execute the resulting -hollow-thorntail.jar file using the Java binary and pass the .war file with your application as the first argument:
```
$ java -jar ./target/myapp-hollow-thorntail.jar ./target/myapp.war
```

Related information

For more information about hollow JARs and their limitations, see Hollow JAR.

3.5. Auto-detecting fractions

Migrating existing legacy applications to benefit from Thorntail is simple when using fraction auto-detection. If you enable the Thorntail Maven plugin in your application, Thorntail detects which APIs you use, and includes the appropriate fractions at build time.

Note	By default, Thorntail only auto-detects if you do not specify any fractions explicitly. This behavior is controlled by the `fractionDetectMode` property. For more information, see the Maven plugin configuration reference.

For example, consider your pom.xml already specifies the API .jar file for a specification such as JAX-RS:

<dependencies>
    <dependency>
      <groupId>org.jboss.spec.javax.ws.rs</groupId>
      <artifactId>jboss-jaxrs-api_2.0_spec</artifactId>
      <version>${version.jaxrs-api}</version>
      <scope>provided</scope>
    </dependency>
</dependencies>

Thorntail then includes the jaxrs fraction during the build automatically.

Prerequisites

An existing Maven-based application with a pom.xml file.

Procedure

Add the thorntail-maven-plugin to your pom.xml in a <plugin> block, with an <execution> specifying the package goal.

<plugins>
  <plugin>
    <groupId>io.thorntail</groupId>
    <artifactId>thorntail-maven-plugin</artifactId>
    <version>${version.thorntail}</version>
    <executions>
      <execution>
        <id>package</id>
        <goals>
          <goal>package</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>

Perform a normal Maven build:
```
$ mvn package
```

Execute the resulting uberjar:

$ java -jar ./target/myapp-thorntail.jar

Related Information

Fractions
Creating an uberjar

3.6. Using explicit fractions

When writing your application from scratch, ensure it compiles correctly and uses the correct version of APIs by explicitly selecting which fractions are packaged with it.

Prerequisites

A Maven-based application with a pom.xml file.

Procedure

Add the BOM to your pom.xml. For more information, see Using a BOM.
Add the Thorntail Maven plugin to your pom.xml. For more information, see Creating an uberjar.

Add one or more dependencies on Thorntail fractions to the pom.xml file:

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>jaxrs</artifactId>
  </dependency>
</dependencies>

Perform a normal Maven build:
```
$ mvn package
```

Execute the resulting uberjar:

$ java -jar ./target/myapp-thorntail.jar

Related Information

Fractions
Auto-detecting fractions

3.7. Creating a datasource

When working with Java applications, a datasource has two components, both equally important:

The JDBC driver
The datasource definition

The task of the JDBC driver is communicating with the database while providing a constant API to application developers. An application must supply its own JDBC driver because of the wide range of available databases and the driver version. Usually, the application does not directly interact with the JDBC driver; instead, the underlying runtime manages creating a datasource, which provides an efficient way to share and manage a discrete connection or a pool of connections to a particular database using the driver.

3.7.1. Configuring a JDBC driver

There are two options how to configure JDBC drivers:

Auto-detecting JDBC drivers

Thorntail has the capability to detect, install, and register a variety of JDBC drivers based on their inclusion as a dependency to your application.

The drivers that Thorntail auto-detects include:

H2 - "h2"
MySQL - "mysql"
PostgreSQL - "postgresql"
Apache Derby - "derby"
Apache Derby Embedded - "derby-embedded"
Apache Hive - "hive2"
MariaDB - "mariadb"
PrestoDB - "prestodb"
EnterpriseDB - "edb"
SQLServer - "sqlserver"
Oracle - "oracle"
Sybase - "sybase"
DB2 - "ibmdb2"
Teiid - "teiid"

Prerequisites

A Maven-based application.
A database to connect to.
The Maven coordinates of the JDBC driver you want to use.

Procedure

Add the appropriate dependencies (with the default <scope>compile</scope> scope) to your application:

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>datasources</artifactId>
  </dependency>
  <dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>${version.h2}</version>
  </dependency>
  <dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>${version.postgresql}</version>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${version.mysql}</version>
  </dependency>
</dependencies>

H2 is the default database in Thorntail.

Configuring the JDBC driver manually

Prerequisites

A Maven-based application.
The module.xml file created according to relevant WildFly instructions. This file is necessary to expose the driver through JBoss Modules.

Procedure

Add the io.thorntail:datasources dependency to the pom.xml file in your application:

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>datasources</artifactId>
  </dependency>
</dependencies>

Edit the project-defaults.yml file to define the driver information.

In the thorntail → datasources → jdbc-drivers tree, define the driver by key, which will be used later for connecting it to the datasource.

thorntail:
  datasources:
    jdbc-drivers:
      myh2:
        driver-class-name: org.h2.Driver
        xa-datasource-name: org.h2.jdbcx.JdbcDataSource
        driver-module-name: com.h2database.h2

3.7.2. Configuring a datasource

Prerequisites

A Maven-based application.
A JDBC Driver configured.

Procedure

Edit the project-defaults.yml file to configure one or more datasources using the JDBC driver of your choice. The configuration is stored under thorntail → datasources → data-sources:

thorntail:
  datasources:
    data-sources:
      MyDS:
        driver-name: myh2
        connection-url: jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
        user-name: sa
        password: sa

3.7.3. Example full project-defaults.yml file

Below, you can see an example project-defaults file that connect to an H2 database.

thorntail:
  datasources:
    data-sources:
      MyDS:
        driver-name: myh2
        connection-url: jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
        user-name: sa
        password: sa
    jdbc-drivers:
      myh2:
        driver-class-name: org.h2.Driver
        xa-datasource-name: org.h2.jdbcx.JdbcDataSource
        driver-module-name: com.h2database.h2

3.8. Testing in a container

Using Arquillian, you have the capability of injecting unit tests into a running application. This allows you to verify your application is behaving correctly. There is an adapter for Thorntail that makes Arquillian-based testing work well with Thorntail–based applications.

Prerequisites

A Maven-based application with a pom.xml file.

Procedure

Include the Thorntail BOM as described in Using a BOM:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>io.thorntail</groupId>
      <artifactId>bom</artifactId>
      <version>${version.thorntail}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

Reference the io.thorntail:arquillian artifact in your pom.xml file with the <scope> set to test:

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>arquillian</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

Create your Application.

Write your application as you normally would; use any default project-defaults.yml files you need to configure it.

thorntail:
  datasources:
    data-sources:
      MyDS:
        driver-name: myh2
        connection-url: jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
        user-name: sa
        password: sa
    jdbc-drivers:
      myh2:
        driver-class-name: org.h2.Driver
        xa-datasource-name: org.h2.jdbcx.JdbcDataSource
        driver-module-name: com.h2database.h2

Create a test class.

Note	Creating an Arquillian test before Thorntail existed usually involved programatically creating `Archive` due to the fact that applications were larger, and the aim was to test a single component in isolation.

package org.wildfly.swarm.howto.incontainer;

public class InContainerTest {
}

Create a deployment.
In the context of microservices, the entire application represents one small microservice component.

Use the @DefaultDeployment annotation to automatically create the deployment of the entire application. The @DefaultDeployment annotation defaults to creating a .war file, which is not applicable in this case because Undertow is not involved in this process.

Apply the @DefaultDeployment annotation at the class level of a JUnit test, along with the @RunWith(Arquillian.class) annotation:
@RunWith(Arquillian.class) @DefaultDeployment(type = DefaultDeployment.Type.JAR) public class InContainerTest {
Using the @DefaultDeployment annotation provided by Arquillian integration with Thorntail means you should not use the Arquillian @Deployment annotation on static methods that return an Archive.

The @DefaultDeployment annotation inspects the package of the test:
package org.wildfly.swarm.howto.incontainer;
From the package, it uses heuristics to include all of your other application classes in the same package or deeper in the Java packaging hierarchy.

Even though using the @DefaultDeployment annotation allows you to write tests that only create a default deployment for sub-packages of your application, it also prevents you from placing tests in an unrelated package, for example:
package org.mycorp.myapp.test;
Write your test code.
Write an Arquillian-type of test as you normally would, including using Arquillian facilities to gain access to internal running components.

In the example below, Arquillian is used to inject the InitialContext of the running application into an instance member of the test case:
@ArquillianResource InitialContext context;
That means the test method itself can use that InitialContext to ensure the Datasource you configured using project-defaults.yml is live and available:
@Test public void testDataSourceIsBound() throws Exception { DataSource ds = (DataSource) context.lookup("java:jboss/datasources/MyDS"); assertNotNull( ds ); }
Run the tests.

Because Arquillian provides an integration with JUnit, you can execute your test classes using Maven or your IDE:
```
$ mvn install
```
Note
In many IDEs, execute a test class by right-clicking it and selecting Run.

3.9. Logging

3.9.1. Enabling logging

Each Thorntail fraction is dependent on the Logging fraction, which means that if you use any Thorntail fraction in your application, logging is automatically enabled on the INFO level and higher. If you want to enable logging explicitly, add the Logging fraction to the POM file of your application.

Prerequisites

A Maven-based application

Procedure

Find the <dependencies> section in the pom.xml file of your application. Verify it contains the following coordinates. If it does not, add them.
```
<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>logging</artifactId>
</dependency>
```
If you want to log messages of a level other than INFO, launch the application while specifying the thorntail.logging system property:
$ mvn thorntail:run -Dthorntail.logging=FINE
See the org.wildfly.swarm.config.logging.Level class for the list of available levels.

3.9.2. Logging to a file

In addition to the console logging, you can save the logs of your application in a file. Typically, deployments use rotating logs to save disk space.

In Thorntail, logging is configured using system properties. Even though it is possible to use the -Dproperty=value syntax when launching your application, it is strongly recommended to configure file logging using the YAML profile files.

Prerequisites

A Maven-based application with the logging fraction enabled. For more information, see Enabling logging.
A writable directory on your file system.

Procedure

Open a YAML profile file of your choice. If you do not know which one to use, open project-defaults.yml in the src/main/resources directory in your application sources. In the YAML file, add the following section:
```
thorntail:
  logging:
```
Configure a formatter (optional). The following formatters are configured by default:
PATTERN

Useful for logging into a file.

COLOR_PATTERN

Color output. Useful for logging to the console.

To configure a custom formatter, add a new formatter with a pattern of your choice in the logging section. In this example, it is called LOG_FORMATTER:
pattern-formatters: LOG_FORMATTER: pattern: "%p [%c] %s%e%n"
Configure a file handler to use with the loggers. This example shows the configuration of a periodic rotating file handler. Under logging, add a periodic-rotating-file-handlers section with a new handler.
periodic-rotating-file-handlers: FILE: file: path: target/MY_APP_NAME.log suffix: .yyyy-MM-dd named-formatter: LOG_FORMATTER level: INFO
Here, a new handler named FILE is created, logging events of the INFO level and higher. It logs in the target directory, and each log file is named MY_APP_NAME.log with the suffix .yyyy-MM-dd. Thorntail automatically parses the log rotation period from the suffix, so ensure you use a format compatible with the java.text.SimpleDateFormat class.
Configure the root logger.
The root logger is by default configured to use the CONSOLE handler only. Under logging, add a root-logger section with the handlers you wish to use:
root-logger: handlers: - CONSOLE - FILE
Here, the FILE handler from the previous step is used, along with the default console handler.

Below, you can see the complete logging configuration section:

The logging section in a YAML configuration profile

thorntail:
  logging:
    pattern-formatters:
      LOG_FORMATTER:
        pattern: "CUSTOM LOG FORMAT %p [%c] %s%e%n"
    periodic-rotating-file-handlers:
      FILE:
        file:
          path: path/to/your/file.log
        suffix: .yyyy-MM-dd
        named-formatter: LOG_FORMATTER
    root-logger:
      handlers:
      - CONSOLE
      - FILE

3.10. Distributed tracing

Thorntail provides ways of simplifying the debugging of your application in a distributed environment.

3.10.1. What is distributed tracing

In the microservices architecture, where multiple services serve a single user request, debugging might be hard. One technique that makes debugging easier is called distributed tracing. Distributed tracing is collecting information about service invocations, correlating it to find all invocations related to a single user request, and visualizing the data in a form that helps you understand the hierarchy of invocations and makes finding problems easier.

Thorntail provides a fraction for MicroProfile OpenTracing, an API for distributed tracing, built on JAX-RS and OpenTracing. Another fraction is provided to configure Jaeger, a popular tracer. Inside the application, you need nothing except these fractions. Outside of the application, a tracer typically runs.

Additional Resources

3.10.2. Tracing a single service

In this example, you can see how to trace a stand-alone "hello world" service. This service does not make any external invocations, so the results are not particularly interesting, but it is useful for building more complex examples.

For the purpose of demonstration, we only configure the Jaeger client to send information about all requests to the tracing server. In a production environment, you can configure more elaborate types of sampling.

In this example, Jaeger runs locally using Docker.

Prerequisites

The Jaeger tracer running in a Docker container on localhost.
Launch the container using the following command:
# docker run -it --rm -p 6831:6831/udp -p 16686:16686 jaegertracing/all-in-one
Wait until the Connected to peer message is displayed in the console.

Procedure

Include the jaxrs, microprofile-opentracing and jaeger fractions in the pom.xml file of your application:

pom.xml

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>jaxrs</artifactId>
  </dependency>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>microprofile-opentracing</artifactId>
  </dependency>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>jaeger</artifactId>
  </dependency>
</dependencies>

Configure the Jaeger tracer in the project-defaults.yml file of your application:
project-defaults.yml
thorntail: jaeger: service-name: greeter sampler-type: const sampler-parameter: 1
All traces sent from this Thorntail application to the tracer server will be identified by the name specified in service-name. The name needs to be unique across the entire network of services.

This example expects the Jaeger server to be running on localhost so that you do not have to configure its location. In a production environment, you must configure the jaeger fraction to specify where traces shall be sent. For example, in an Istio environment with Jaeger installed, the configuration might look like this:
project-istio.yml
thorntail: jaeger: service-name: greeter sampler-type: const sampler-parameter: 1 enable-b3-header-propagation: true remote-reporter-http-endpoint: 'http://jaeger-collector.istio-system:14268/api/traces'
Create a JAX-RS resource, for example:
MySimpleResource.java
@GET public String get() { return "Hello from traced endpoint"; }
All JAX-RS resources are automatically traced. You can customize this behavior using the @Traced annotation from MicroProfile OpenTracing.
Launch your application:
```
$ mvn thorntail:run
```

Invoke the traced endpoint several times:

$ curl http://localhost:8080/simple
Hello from traced endpoint

See the traces in Jaeger UI:

Open the Jaeger UI at http://localhost:16686/, select greeter under Service and click Find Traces. You can see all the requests you performed and basic information about them.

Additional resources

For more information about configuring Jaeger sampling, see the Jaeger documentation.

3.10.3. Tracing a complex service

In this example, you can see how to trace a more complex service that performs an external service invocation. To keep the example easy to use, the application actually calls itself, but in a way that is equivalent to calling services outside of the application.

In this example, Jaeger runs locally using Docker.

Prerequisites

A simple service tracing configured.

Procedure

If the Jaeger tracer is running, restart it:
1. Open the console where the container with Jaeger is running and stop it by pressing Ctrl + C.
2. Relaunch the container by running:
  # docker run -it --rm -p 6831:6831/udp -p 16686:16686 jaegertracing/all-in-one

Use JAX-RS Client to invoke an external service, for example:

MyComplexResource.java

@Inject
private MyService service;

@GET
public String get() {
    return service.call();
}

MyService.java

@Traced
public String call() {
    Client client = ClientTracingRegistrar.configure(ClientBuilder.newBuilder()).build();
    try {
        String response = client.target("http://localhost:8080")
                .path("/simple")
                .request()
                .get(String.class);
        return "Called an external service successfully, it responded: " + response;
    } finally {
        client.close();
    }
}

Here, you can see that not only JAX-RS resource methods can be traced. This is a regular method in a CDI bean. Unlike JAX-RS resources, which are traced automatically, other methods need the explicit @Traced annotation.

The most important part is this usage of MicroProfile OpenTracing API:

Client client = ClientTracingRegistrar.configure(ClientBuilder.newBuilder()).build();

This snippet shows how MicroProfile OpenTracing integrates with JAX-RS Client to ensure the trace is propagated across services. Without the integration, it would be impossible to correlate the invocations as part of a single user request.

Note	Currently, MicroProfile OpenTracing does not integrate with MicroProfile RestClient, so you need to use a pure JAX-RS Client. This limitation will be removed in the future, see MicroProfile OpenTracing issue #82.

Launch your application:
```
$ mvn thorntail:run
```
Invoke the traced endpoint several times:
$ curl http://localhost:8080/complex Called an external service successfully, it responded: Hello from traced endpoint
Notice how the complex service calls the simple service, which you configured in the simple service example. Both of these services are traced, so we can see the invocation of the simple service as a part of the complex invocation.
See the traces in Jaeger UI.
Reload the Jaeger UI at http://localhost:16686/, select greeter under Service and click Find Traces. You can see all the requests you performed and basic information about them.

Click on one of the traces to show detailed information about that particular request:
- At the top level, you can see the JAX-RS resource method MyComplexResource.get.
- Under it, you can see the invocation of MyService.call method.
- Under that, you can see that this method performed a GET request to another service.
- Under the GET request, you can see the JAX-RS resource method MySimpleResource.get.
For all these invocations, you can see how long they took and when they occurred as part of the entire request processing.

3.11. Metrics

Thorntail provides ways of exposing application metrics in order to track performance and service availability.

3.11.1. What are metrics

In the microservices architecture, where multiple services are invoked in order to serve a single user request, diagnosing performance issues or reacting to service outages might be hard. To make solving problems easier, applications must expose machine-readable data about their behavior, such as:

How many requests are currently being processed.
How many connections to the database are currently in use.
How long service invocations take.

These kinds of data are referred to as metrics. Collecting metrics, visualizing them, setting alerts, discovering trends, etc. are very important to keep a service healthy.

Thorntail provides a fraction for MicroProfile Metrics, an easy-to-use API for exposing metrics. Among other formats, it supports exporting data in the native format of Prometheus, a popular monitoring solution. Inside the application, you need nothing except this fraction. Outside of the application, Prometheus typically runs.

Additional resources

The MicroProfile Metrics GitHub page.
The Prometheus homepage
A popular solution to visualize metrics stored in Prometheus is Grafana. For more information, see the Grafana homepage.

3.11.2. Exposing metrics

In this example, you:

Configure your application to expose metrics.
Collect and view the data using Prometheus.

Note that Prometheus actively connects to a monitored application to collect data; the application does not actively send metrics to a server.

Prerequisites

Prometheus configured to collect metrics from the application:
1. Get the default Prometheus configuration using the following command:
  
  # docker run -it --rm --entrypoint /bin/sh prom/prometheus -c 'cat /etc/prometheus/prometheus.yml'
  
  Store the output in the prometheus.yml file in the directory with your application.
2. Append the following snippet to the prometheus.yml file to make Prometheus automatically collect metrics from your application:
  
  - job_name: 'thorntail' static_configs: - targets: ['localhost:8080']
  
  The default behavior of Thorntail-based applications is to expose metrics at the /metrics endpoint. This is what the MicroProfile Metrics specification requires, and also what Prometheus expects.
The Prometheus server running on localhost using Docker:
# docker run -it --rm --network host -p 9090:9090 -v $PWD/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus
Wait until the Server is ready to receive web requests message is displayed in the console.

Notice the --network host option so that Prometheus can connect to your application.

Procedure

Include the microprofile-metrics fraction in your pom.xml.

pom.xml

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>microprofile-metrics</artifactId>
  </dependency>
</dependencies>

Annotate methods or classes with the metrics annotations, for example:
@GET @Counted(monotonic = true, name = "hello-count", absolute = true) @Timed(name = "hello-time", absolute = true) public String get() { return "Hello from counted and timed endpoint"; }
Here, the @Counted(monotonic = true) annotation is used to keep track of how many times this method was invoked. The @Timed annotation is used to keep track of how long the invocations took.

In this example, a JAX-RS resource method was annotated directly, but you can annotate any CDI bean in your application as well.
Launch your application:
```
$ mvn thorntail:run
```

Invoke the traced endpoint several times:

$ curl http://localhost:8080/
Hello from counted and timed endpoint

Wait at least 15 seconds for the collection to happen, and see the metrics in Prometheus UI:
1. Open the Prometheus UI at http://localhost:9090/ and type hello into the Expression box.
2. From the suggestions, select for example application:hello_count and click Execute.
3. In the table that is displayed, you can see how many times the resource method was invoked.
4. Alternatively, select application:hello_time_mean_seconds to see the mean time of all the invocations.
Note that all metrics you created are prefixed with application:. There are other metrics, automatically exposed by Thorntail as the MicroProfile Metrics specification requires. Those metrics are prefixed with base: and vendor: and expose information about the JVM in which the application runs.

Additional resources

For additional types of metrics, see the MicroProfile Metrics documentation.

4. Advanced

4.1. How to Create a Fraction

4.1.1. Introduction

The composable pieces of Thorntail are called fractions. Each fraction starts with a single Maven-addressable artifact which may transitively bring in others.

4.1.2. The `pom.xml`

It is useful to set at least a pair of properties, specifying the version of the Thorntail SPI and fraction-plugin being used:

<properties>
  <version.thorntail>2.2.1.Final</version.thorntail>
  <version.thorntail.fraction-plugin>87</version.thorntail.fraction-plugin>
</properties>

You can include all of the primary bits of Thorntail using the bom-all artifact in a <dependencyManagement> import. Additionally, you’ll need two more dependencies added in order to write CDI components to configure the server.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>io.thorntail</groupId>
      <artifactId>bom-all</artifactId>
      <version>${version.thorntail}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>javax.enterprise</groupId>
    <artifactId>cdi-api</artifactId>
    <scope>provided</scope>
  </dependency>
</dependencies>

Additionally, the thorntail-fraction-plugin should be configured within the parent pom.xml so that it fires for every sub-module:

<build>
  <plugins>
    <plugin>
      <groupId>io.thorntail</groupId>
      <artifactId>thorntail-fraction-plugin</artifactId>
      <version>${version.thorntail.fraction-plugin}</version>
      <executions>
        <execution>
          <phase>process-classes</phase>
          <goals>
            <goal>process</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

4.1.3. What’s in a Fraction

A "fraction" can include all or none of the following components. Ultimately a fraction contributes configuration or capabilities to a runtime system.

Package Layout

For a given fraction, a unique package root is required. In the usual case of the core code, it matches the pattern of org.wildfly.swarm.CAPABILITY, such as org.wildfly.swarm.undertow or org.wildfly.swarm.naming.

Within the root there may be additional sub-packages with special meaning:

The org.wildfly.swarm.CAPABILITY.runtime package holds classes that are considered "back-end" components, loaded via our internal CDI implementation in order to configure and setup the server.
The org.wildfly.swarm.CAPABILITY.deployment package holds other classes that should not be considered either part of the front-end API of the fraction exposed to users, nor a part of the back-end components to configure the server. Instead, the .deployment package is a sidecar to hold additional classes that may be added to deployment archives.
The org.wildfly.swarm.CAPABILITY.detect package holds fraction autodetection logic classes. See also Auto-detection.

The thorntail-fraction-plugin automatically generates a number of module.xml descriptors depending on what features it has found in the fraction. Each generated module descriptor is used to isolate a particular part of a fraction functionality. E.g. a fraction module with deployment slot (which includes the content of org.wildfly.swarm.CAPABILITY.deployment) is automatically added as a module dependency to any deployment. It’s a convenient way to add code into the user deployment for handling integrations with the container. Or, for example, a fraction module with runtime slot is used to load the fraction and any of its runtime code.

Note	The generated descriptors may be overriden by providing the corresponding module.xml in the `src/main/resources/modules` directory.

The `module.conf`

Alongside your pom.xml you need at least an empty module.conf file to signal the plugin that your build is actually a fraction.

This file is used to enumerate the JBoss-Modules dependencies your fraction may have, and helps produce the resulting module.xml files for your fraction.

In this file, one per line, you may list the module dependencies you may have. If your fraction relies on runtime linking to other fractions, they should typically be listed in this file.

org.jboss.logging
org.wildfly.swarm.undertow

The `*Fraction.java`

If the fraction includes configuration capabilities, or otherwise modifies the runtime system through deployments or adjustments to the server, it may include an implementation of org.wildfly.swarm.spi.api.Fraction.

Any opaque POJO configuration details that are required may be added in the implementation, and will be made available to the back-end runtime portion during server boot-up to control configuration.

In the event that no particular configuration values are required, no Fraction implementation is required. If provided, it should reside in the absolute root of the fraction java package, such as org.wildfly.swarm.undertow.UndertowFraction.

package com.mycorp.cheese;

import java.util.Set;
import java.util.HashSet;
import org.wildfly.swarm.spi.api.Fraction;

public class CheeseFraction implements Fraction {
  // arbitrary configuration parameters are allowed

  public void cheese(String type) {
    this.cheeses.add( type );
  }

  public void cheeses(Set<String> types) {
    this.cheeses.addAll( types );
  }

  public Set<String> cheeses() {
    return this.cheeses;
  }

  private Set<String> cheeses = new HashSet<>();
}

Runtime CDI Components

Within the runtime sub-package of the fraction, a variety of CDI-enabled components may be used. Within these classes, you can use typical CDI mechanisms such as @Inject, @Produces, and Instance<> in order to accomplish whatever is required for your fraction. Typically these components would, at the minimum, inject their own fraction.

@ApplicationScoped
public class MyComponent implements Whatever {

  @Inject
  private MyFraction myFraction;

}

`DeploymentProcessor`

If your fraction needs an opportunity to process the deployment, e.g. to alter or otherwise prepare the deployed archive or to process Jandex metadata of the deployed archive, you may implement the org.wildfly.swarm.spi.api.DeploymentProcessor interface. The implementation class should be marked as @DeploymentScoped.

@DeploymentScoped
public class MyDeploymentProcessor implements DeploymentProcessor {

  @Inject
  private MyFraction myFraction;

  @Inject
  private Archive archive;

  @Inject
  private IndexView index;

  public void process() {
     archive.as(WARArchive.class).setContextRoot(myFraction.getContextRoot());
  }
}

`Customizer`

Most of the heavy-lifting of configuration may occur within implementations of org.wildfly.swarm.spi.api.Customizer.

If your fraction is always present with other fractions, cross-fraction manipulation may be achieved.

Two different executions of Customizers occur. All customizers annotated with @Pre are fired, followed by all annotated with @Post.

@Post
@ApplicationScoped
public class MyCustomizer implements Customizer {

  @Inject
  private MyFraction myFraction;

  @Inject
  private UndertowFraction undertowFraction;

  public void customize() {
    if ( undertowHasSSL() ) {
      doSomethingSpecialWithMyFraction()
    }
  }
}

`Archive` producers

In some cases, a fraction implicitly produces a deployment archive by its simple presence in the dependency graph. For example, including io.thorntail:jolokia ensures that the Jolokia web-app is deployed. This is accomplished by having a CDI component that @Produces a ShrinkWrap Archive. No particular interface is required to be implemented.

@ApplicationScoped
public MyArchiveProducers {

  @Inject
  private MyFraction myFraction;

  @Produces
  Archive myManagementConsole() {
    WARArchive archive = ...  // produces the Archive any way you like
    archive.setContextRoot( myFraction.getContextRoot() );
    return archive;
  }
}

`@Configurable` and `Defaultable<>`

When creating a new Fraction implementation, each of its fields will automatically be configurable through the project-*.yml mechanisms. In the case that different names for the configurable items are desired, the @Configuration annotation may be used.

Additionally, the @AttributeDocumentation annotation should be used on all fields in order to provide documentation, both in the reference-guide and through the --config-help commandline capabilities.

@Configurable("thorntail.myfraction.taco")
@AttributeDocumentation("Determines the type of taco to expose.")
private String tacoType;

In the event that there should be a default value provided if the user provides none, the Defaultable<T> type is useful. The class also provided type-safe static method for initializing the defaultable item.

@Configurable("thorntail.myfraction.taco")
@AttributeDocumentation("Determines the type of taco to expose.")
private Defaultable<String> tacoType = Defaultable.string("soft");

Each of these may also be applied to fields within ArchivePreparer, ArchiveMetadataProcessor, and Customizer implementations. By default, no fields from these items will be considered configurable unless explicitly marked as @Configurable.

Generally speaking, it is easier to push all configurable bits to the related *Fraction implementation, and @Inject the fraction into the relevant CDI components.

Auto-detection

An important point of Thorntail is the capability of the plugin to autodetect that a fraction is required. Currently this is only supported by fractions that are part of the core Thorntail distribution. In the event that your fraction is merged into core, you will want to possibly also support auto-detection.

This is accomplished by placing detection logic classes within the .detect.* subpackage of your fraction.

This functionality is still evolving, and thus not terribly well documented yet.

An example of detecting a fraction (in this case the Batch JBeret fraction) based on application usage of a given API:

package org.wildfly.swarm.batch.jberet.detect;

import org.wildfly.swarm.spi.meta.PackageFractionDetector;

public class BatchPackageDetector extends PackageFractionDetector {

    public BatchPackageDetector() {
        anyPackageOf("javax.batch");
    }

    @Override
    public String artifactId() {
        return "batch-jberet";
    }
}

Transitive dependencies

If your fraction depends upon the presence of a Servlet container being configured, you should add a dependency on the necessary fractions into your pom.xml

<dependencies>
  <dependency>
    <groupId>io.thorntail</groupId>
    <artifactId>undertow</artifactId>
  </dependency>
</dependencies>

By doing this, a user must only include your fraction, and the Undertow fraction will be dragged along implicitly into their application.

Logging

Each fraction should use the jboss-logging framework along with the appropriate plugins to enable localization.

Include the following <dependency> items within your pom.xml:

<dependency>
  <groupId>org.jboss.logging</groupId>
  <artifactId>jboss-logging-annotations</artifactId>
  <scope>provided</scope>
  <optional>true</optional>
</dependency>
<dependency>
  <groupId>org.jboss.logging</groupId>
  <artifactId>jboss-logging-processor</artifactId>
  <scope>provided</scope>
  <optional>true</optional>
</dependency>

Each fraction that requires logging should then include a related *Messages class akin to:

@MessageLogger(projectCode = "WFSMYFRAC", length = 4)
public interface MyFractionMessages extends BasicLogger {

    MyFractionMessages MESSAGES = Logger.getMessageLogger(MyFractionMessages.class, "org.wildfly.swarm.myfraction");

    @LogMessage(level = Logger.Level.ERROR)
    @Message(id = 1, value = "Error eating a taco: %s.")
    void errorEatingTaco(String tacoDescriptor, @Cause Throwable t);

}

Now, typesafe logging may occur such as

try {
  ...
} catch (TacoException t) {
  MyFractionMessages.MESSAGES.errorEatingTaco("crunchy", t);
}

Reference

5. General

5.1. Using Thorntail Maven Plugin

Thorntail provides a Maven plugin to accomplish most of the work of building uberjar packages.

5.1.1. Thorntail Maven plugin general usage

The Thorntail Maven plugin is used like any other Maven plugin, that is through editing the pom.xml file in your application and adding a <plugin> section:

<plugin>
  <groupId>io.thorntail</groupId>
  <artifactId>thorntail-maven-plugin</artifactId>
  <version>${version.thorntail}</version>
  <executions>
    ...
    <execution>
      <goals>
        ...
      </goals>
      <configuration>
        ...
      </configuration>
    </execution>
  </executions>
</plugin>

5.1.2. Thorntail Maven plugin goals

The Thorntail Maven plugin provides several goals:

package: Creates the executable package (see Creating an uberjar).
run: Executes your application in the Maven process. The application is stopped if the Maven build is interrupted, for example when you press Ctrl + C.

start and multistart

Executes your application in a forked process. Generally, it is only useful for running integration tests using a plugin, such as the maven-failsafe-plugin. The multistart variant allows starting multiple Thorntail–built applications using Maven GAVs to support complex testing scenarios.

stop

Stops any previously started applications.

Note	The `stop` goal can only stop applications that were started in the same Maven execution.

5.1.3. Thorntail Maven plugin configuration options

The Thorntail Maven plugin accepts the following configuration options:

bundleDependencies

If true, dependencies will be included in the -thorntail.jar file. Otherwise, they will be resolved from $M2_REPO or the network at runtime.

Property

thorntail.bundleDependencies

Default

true

Used by

package

debug

The port to use for debugging. If set, the thorntail process will suspend on start and open a debugger on this port.

Property

thorntail.debug.port

Default

Used by

run, start

environment

A properties-style list of environment variables to use when executing the application.

Property

none

Default

Used by

multistart, run, start

environmentFile

A .properties file with environment variables to use when executing the application.

Property

thorntail.environmentFile

Default

Used by

multistart, run, start

fractionDetectMode

The mode of fraction detection. The available options are:

when_missing: Runs only when no Thorntail dependencies are found.
force: Always run, and merge any detected fractions with the existing dependencies. Existing dependencies take precedence.
never: Disable fraction detection.

Property

thorntail.detect.mode

Default

when_missing

Used by

package, run, start

fractions

A list of extra fractions to include when auto-detection is used. It is useful for fractions that cannot be detected or user-provided fractions.

The format of specifying a fraction can be: * group:artifact:version * artifact:version * artifact

If no group is provided, io.thorntail is assumed.

If no version is provided, the version is taken from the Thorntail BOM for the version of the plugin you are using.

If the value starts with the character ! a corresponding auto-detected fraction is not installed (unless it’s a dependency of any other fraction). In the following example the Undertow fraction is not installed even if your application references a class from the javax.servlet package:

<plugin>
  <groupId>io.thorntail</groupId>
  <artifactId>thorntail-maven-plugin</artifactId>
  <version>${version.thorntail}</version>
  <executions>
    <execution>
      <goals>
        <goal>package</goal>
      </goals>
      <configuration>
       <fractions>
         <fraction>!undertow</fraction>
       </fractions>
      </configuration>
    </execution>
  </executions>
</plugin>

Property

none

Default

Used by

package, run, start

hollow

Specifies if the resulting executable JAR should be hollow, and therefore not include the default deployment.

Property

thorntail.hollow

Default

false

Used by

package

jvmArguments

A list of <jvmArgument> elements specifying additional JVM arguments (such as -Xmx32m).

Property

thorntail.jvmArguments

Default

Used by

multistart, run, start

modules

Paths to a directory containing additional module definitions.

Property

none

Default

Used by

package, run, start

processes

Application configurations to start (see multistart).

Property

none

Default

Used by

multistart

properties

See Thorntail Maven plugin configuration properties.

Property

none

Default

Used by

package, run, start

propertiesFile

See Thorntail Maven plugin configuration properties.

Property

thorntail.propertiesFile

Default

Used by

package, run, start

stderrFile

A file path where to store the stderr output instead of sending it to the stderr output of the launching process.

Property

thorntail.stderr

Default

Used by

run, start

stdoutFile

A file path where to store the stdout output instead of sending it to the stdout output of the launching process.

Property

thorntail.stdout

Default

Used by

run, start

useUberJar

If specified, the -thorntail.jar file located in ${project.build.directory} is used. This JAR is not created automatically, so make sure you execute the package goal first.

Property

thorntail.useUberJar

Default

Used by

run, start

Note

Before version 2.3.0.Final, this property was called wildfly-swarm.useUberJar, and only setting it to true enabled this behavior: -Dwildfly-swarm.useUberJar=true. You can continue using the old name, but consider using the new variant, which does not require setting a value: -Dthorntail.useUberJar.

5.1.4. Thorntail Maven plugin configuration properties

Properties can be used to configure the execution and affect the packaging or running of your application.

If you add a <properties> or <propertiesFile> section to the <configuration> of the plugin, the properties are used when executing your application using the mvn thorntail:run command. In addition to that, the same properties are added to your myapp-thorntail.jar file to affect subsequent executions of the uberjar. Any properties loaded from the <propertiesFile> override identically-named properties in the <properties> section.

Any properties added to the uberjar can be overridden at runtime using the traditional -Dname=value mechanism of the java binary, or using the YAML-based configuration files.

Only the following properties are added to the uberjar at package time:

The properties specified outside of the <properties> section or the <propertiesFile>, whose path starts with one of the following:
- jboss.
- wildfly.
- thorntail.
- swarm.
- maven.
The properties that override a property specified in the <properties> section or the <propertiesFile>.

5.2. Configuring a Thorntail application

You can configure numerous options with applications built with Thorntail. For most options, reasonable defaults are already applied, so you do not have to change any options unless you explicitly want to.

This reference is a complete list of all configurable items, grouped by the fraction that introduces them. Only the items related to the fractions that your application uses are relevant to you.

5.2.1. System properties

Using system properties for configuring your application is advantageous for experimenting, debugging, and other short-term activities.

Commonly used system properties

This is a non-exhaustive list of system properties you are likely to use in your application:

General system properties

swarm.bind.address

The interface to bind servers

Default

0.0.0.0

swarm.port.offset

The global port adjustment

Default

swarm.context.path

The context path for the deployed application

Default

swarm.http.port

The port for the HTTP server

Default

8080

swarm.https.port

The port for the HTTPS server

Default

8483

swarm.debug.port

If provided, the swarm process will pause for debugging on the given port.

This option is only available when running an Arquillian test or starting the application using the mvn wildfly-swarm:run command, not when executing a JAR file. The JAR file execution requires normal Java debug agent parameters.

Default

With the H2, MySQL, and Postgres database fractions, use the following properties to configure the datasource:

Datasource-related system properties

swarm.ds.name

The name of the datasource

Default

ExampleDS

swarm.ds.username

The user name to access the database

Default

driver-specific

swarm.ds.password

The password to access the database

Default

driver-specific

swarm.ds.connection.url

The JDBC Connection URL

Default

driver-specific

Note	For a full set of available properties, see the documentation for each fraction and the javadocs on class SwarmProperties.java

Application configuration using system properties

Configuration properties are presented using dotted notation, and are suitable for use as Java system property names, which your application consumes through explicit setting in the Maven plugin configuration, or through the command line when your application is being executed.

Any property that has the KEY parameter in its name indicates that you must supply a key or identifier in that segment of the name.

Configuration of items with the KEY parameter

A configuration item documented as thorntail.undertow.servers.KEY.default-host indicates that the configuration applies to a particular named server.

In practical usage, the property would be, for example, thorntail.undertow.servers.default.default-host for a server known as default.

Setting system properties using the Maven plugin

Setting properties using the Maven plugin is useful for temporarily changing a configuration item for a single execution of your Thorntail application.

Note	Even though the configuration in the POM file of your application is persistent, it is not recommended to use it for long-term configuration of your application. Instead, use the YAML configuration files.

If you want to set explicit configuration values as defaults through the Maven plugin, add a <properties> section to the <configuration> block of the plugin in the pom.xml file in your application.

Prerequisites

Your Thorntail-based application with a POM file

Procedure

In the POM file of your application, locate the configuration you want to modify.

Insert a block with configuration of the io.thorntail:thorntail-maven-plugin artifact, for example:

<build>
  <plugins>
    <plugin>
      <groupId>io.thorntail</groupId>
      <artifactId>thorntail-maven-plugin</artifactId>
      <version>2.2.1.Final</version>
      <configuration>
        <properties>
          <thorntail.bind.address>127.0.0.1</thorntail.bind.address>
          <java.net.preferIPv4Stack>true</java.net.preferIPv4Stack>
        </properties>
      </configuration>
    </plugin>
  </plugins>
</build>

In the example above, the thorntail.bind.address property is set to 127.0.0.1 and the java.net.preferIPv4Stack property is set to true.

Setting system properties using the command line

Setting properties using the Maven plugin is useful for temporarily changing a configuration item for a single execution of your Thorntail application.

You can customize an environment-specific setting or experiment with configuration items before setting them in a YAML configuration file.

To use a property on the command line, pass it as a command-line parameter to the Java binary:

Prerequisites

A JAR file with your application

Procedure

In a terminal application, navigate to the directory with your application JAR file.
Execute your application JAR file using the Java binary and specify the property and its value:
$ java -Dthorntail.bind.address=127.0.0.1 -jar myapp-thorntail.jar
In this example, you assing the value 127.0.0.1 to the property called thorntail.bind.address.

Specifying JDBC drivers for hollow JARs

When executing a hollow JAR, you can specify a JDBC Driver JAR using the thorntail.classpath property. This way, you do not need to package the driver in the hollow JAR.

The thorntail.classpath property accepts one or more paths to JAR files separated by ; (a semicolon). The specified JAR files are added to the classpath of the application.

Prerequisites

A JAR file with your application

Procedure

In a terminal application, navigate to the directory with your application JAR file.

Execute your application JAR file using the Java binary and specify the JDBC driver:

$ java -Dthorntail.classpath=./h2-1.4.196.jar -jar microprofile-jpa-hollow-thorntail.jar example-jpa-jaxrs-cdi.war

5.2.2. YAML files

YAML is the preferred method for long-term configuration of your application. In addition to that, the YAML strategy provides grouping of environment-specific configurations, which you can selectively enable when executing the application.

The general YAML file format

The Thorntail configuration item names correspond to the YAML configuration structure.

Example 1. YAML configuration

For example, a configuration item documented as thorntail.undertow.servers.KEY.default-host translates to the following YAML structure, substituting the KEY segment with the default identifier:

thorntail:
  undertow:
    servers:
      default:
        default-host: <myhost>

Default Thorntail YAML Files

By default, Thorntail looks up permanent configuration in files with specific names to put on the classpath.

project-defaults.yml

If the original .war file with your application contains a file named project-defaults.yml, that file represents the defaults applied over the absolute defaults that Thorntail provides.

Other default file names

In addition to the project-defaults.yml file, you can provide specific configuration files using the -S <name> command-line option. The specified files are loaded, in the order you provided them, before project-defaults.yml. A name provided in the -S <name> argument specifies the project-<name>.yml file on your classpath.

Example 2. Specifying configuration files on the command line

Consider the following application execution:

$ java -jar myapp-thorntail.jar -Stesting -Scloud

The following YAML files are loaded, in this order. The first file containing a given configuration item takes precedence over others:

project-testing.yml
project-cloud.yml
project-defaults.yml

Non-default Thorntail YAML configuration files

In addition to default configuration files for your Thorntail-based application, you can specify YAML files outside of your application. Use the -s <path> command-line option to load the desired file.

Both the -s <path> and -S <name> command-line options can be used at the same time, but files specified using the -s <path> option take precedence over YAML files contained in your application.

Example 3. Specifying configuration files inside and outside of the application

Consider the following application execution:

$ java -jar myapp-thorntail.jar -s/home/app/openshift.yml -Scloud -Stesting

The following YAML files are loaded, in this order:

/home/app/openshift.yml
project-cloud.yml
project-testing.yml
project-defaults.yml

The same order of preference is applied even if you invoke the application as follows:

$ java -jar myapp-thorntail.jar -Scloud -Stesting -s/home/app/openshift.yml

Related information

Default Thorntail YAML Files

5.3. Network configuration

For network configuration, create or adjust interfaces, socket-bindings, and outbound-socket-bindings. The networking configuration is stored under the network → thorntail key.

5.3.1. Interfaces

An interface represents a known ethernet interface. By default, the interface named public is bound to the 0.0.0.0 IP address, which represents all known interfaces of the underlying machine. This includes both publicly-routed interfaces, and the localhost (127.0.0.1) interface.

In addition to that, when you include the management fraction in an application, an interface named management is also provisioned, and it is bound only to localhost.

Example 4. Additional interface configuration

The following interface is called backnet, and is bound to the 192.168.4.5 address.

thorntail:
  network:
    interfaces:
      backnet:
        bind: 192.168.4.5

If you want to change the bind address for the public or management interfaces, use special properties, which are defined for these two cases in particular:

thorntail.bind.address
thorntail.management.bind.address

Change the underlying addresses by changing the above properties or their related YAML values.

5.3.2. Sockets

Socket bindings and outbound socket bindings allow externalized configuration of sockets and ports bound to a particular interface. Use regular socket-bindings for inbound connections, while outbound-socket-bindings denote connections capable of changing to remote locations.

Socket-binding groups

Groups of bindings occur within socket binding groups, where standard-sockets is the default group. You can bind the sockets of an entire group to a given default interface, or you can offset all members of the group by a particular number of ports.

Example 5. Socket-binding group

The ports of the standard-sockets default group are offset by 10:

thorntail:
  network:
    socket-binding-groups:
      standard-sockets:
        port-offset: 10
        default-interface: public

Example 6. Socket binding

Socket-bindings may be created or adjusted within a socket-binding-group:

thorntail:
  network:
    socket-binding-groups:
      standard-sockets:
        http:
          port: 8081

Example 7. Outbound socket binding

To create a named outbound socket binding for connection to remote endpoints, define outbound-socket-bindings in a socket-binding-group:

thorntail:
  network:
    socket-binding-groups:
      standard-sockets:
        outbound-socket-bindings:
              neo4jtesthost:
                remote-host: localhost
                remote-port: 7687

5.4. The usage.txt file

Each Thorntail application can contain a text file with usage instructions at one of the following locations:

/usage.txt
/META-INF/usage.txt
/WEB-INF/usage.txt

When the application has fully started, the contents of the file are be logged to the logging output, with variables substituted according to the configuration properties. This is useful for displaying the currently active port used by the application, for example.

Reference the configuration variables in the ${thorntail.thing} format:

The application is now ready on ${thorntail.http.port}!

6. Fractions

6.1. Archaius

Warning

This fraction is deprecated.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>archaius</artifactId>
</dependency>

6.2. AsciidoctorJ

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>asciidoctorj</artifactId>
</dependency>

6.3. Batch (JBeret)

The Batch fraction provides support for scheduled job execution, through JSR-352.

For additional information about JBeret please see the JBeret User’s Guide.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>batch-jberet</artifactId>
</dependency>

Configuration

swarm.batch.default-job-repository: The name of the default job repository.
swarm.batch.default-thread-pool: The name of the default thread-pool.
swarm.batch.jdbc-job-repositories.KEY.data-source: The data source name used to connect to the database.
swarm.batch.restart-jobs-on-resume: If set to true when a resume operation has be invoked after a suspend operation any jobs stopped during the suspend will be restarted. A value of false will leave the jobs in a stopped state.
swarm.batch.security-domain: References the security domain for batch jobs. This can only be defined if the Elytron subsystem is available.
swarm.batch.thread-factories.KEY.group-name: Specifies the name of a thread group to create for this thread factory.
swarm.batch.thread-factories.KEY.name: The name of the created thread factory.
swarm.batch.thread-factories.KEY.priority: May be used to specify the thread priority of created threads.
swarm.batch.thread-factories.KEY.thread-name-pattern: The template used to create names for threads. The following patterns may be used: %% - emit a percent sign %t - emit the per-factory thread sequence number %g - emit the global thread sequence number %f - emit the factory sequence number %i - emit the thread ID.
swarm.batch.thread-pools.KEY.active-count: The approximate number of threads that are actively executing tasks.
swarm.batch.thread-pools.KEY.completed-task-count: The approximate total number of tasks that have completed execution.
swarm.batch.thread-pools.KEY.current-thread-count: The current number of threads in the pool.
swarm.batch.thread-pools.KEY.keepalive-time: Used to specify the amount of time that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.batch.thread-pools.KEY.largest-thread-count: The largest number of threads that have ever simultaneously been in the pool.
swarm.batch.thread-pools.KEY.max-threads: The maximum thread pool size. Note this should always be greater than 3. Two threads are reserved to ensure partition jobs can execute as expected.
swarm.batch.thread-pools.KEY.name: The name of the thread pool.
swarm.batch.thread-pools.KEY.queue-size: The queue size.
swarm.batch.thread-pools.KEY.rejected-count: The number of tasks that have been rejected.
swarm.batch.thread-pools.KEY.task-count: The approximate total number of tasks that have ever been scheduled for execution.
swarm.batch.thread-pools.KEY.thread-factory: Specifies the name of a specific thread factory to use to create worker threads. If not defined an appropriate default thread factory will be used.

6.4. Bean Validation

Provides class-level constraint and validation according to JSR 303.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>bean-validation</artifactId>
</dependency>

6.5. Camel Core

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-core</artifactId>
</dependency>

Configuration

thorntail.camel.contexts: (not yet documented)
thorntail.camel.route-builders: (not yet documented)

6.5.1. Camel Component :: Activemq

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-activemq</artifactId>
</dependency>

6.5.2. Camel Component :: Ahc

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ahc</artifactId>
</dependency>

Camel Component :: Ahc-ws

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ahc-ws</artifactId>
</dependency>

6.5.3. Camel Component :: Amqp

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-amqp</artifactId>
</dependency>

6.5.4. Camel Component :: Atom

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-atom</artifactId>
</dependency>

6.5.5. Camel Component :: Avro

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-avro</artifactId>
</dependency>

6.5.6. Camel Component :: Aws

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-aws</artifactId>
</dependency>

6.5.7. Camel Component :: Barcode

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-barcode</artifactId>
</dependency>

6.5.8. Camel Component :: Base64

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-base64</artifactId>
</dependency>

6.5.9. Camel Component :: Bean-validator

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-bean-validator</artifactId>
</dependency>

6.5.10. Camel Component :: Beanio

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-beanio</artifactId>
</dependency>

6.5.11. Camel Component :: Bindy

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-bindy</artifactId>
</dependency>

6.5.12. Camel Component :: Box

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-box</artifactId>
</dependency>

6.5.13. Camel Component :: Braintree

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-braintree</artifactId>
</dependency>

6.5.14. Camel Component :: Cassandraql

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-cassandraql</artifactId>
</dependency>

6.5.15. Camel Component :: Castor

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-castor</artifactId>
</dependency>

6.5.16. Camel Component :: Cdi

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-cdi</artifactId>
</dependency>

6.5.17. Camel Component :: Coap

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-coap</artifactId>
</dependency>

6.5.18. Camel Component :: Context

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-context</artifactId>
</dependency>

6.5.19. Camel Component :: Couchdb

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-couchdb</artifactId>
</dependency>

6.5.20. Camel Component :: Crypto

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-crypto</artifactId>
</dependency>

6.5.21. Camel Component :: Csv

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-csv</artifactId>
</dependency>

6.5.22. Camel Component :: Cxf

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-cxf</artifactId>
</dependency>

6.5.23. Camel Component :: Dns

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-dns</artifactId>
</dependency>

6.5.24. Camel Component :: Dozer

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-dozer</artifactId>
</dependency>

6.5.25. Camel Component :: Dropbox

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-dropbox</artifactId>
</dependency>

6.5.26. Camel Component :: Ejb

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ejb</artifactId>
</dependency>

6.5.27. Camel Component :: Elasticsearch

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-elasticsearch</artifactId>
</dependency>

6.5.28. Camel Component :: Elsql

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-elsql</artifactId>
</dependency>

6.5.29. Camel Component :: Exec

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-exec</artifactId>
</dependency>

6.5.30. Camel Component :: Facebook

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-facebook</artifactId>
</dependency>

6.5.31. Camel Component :: Flatpack

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-flatpack</artifactId>
</dependency>

6.5.32. Camel Component :: Freemarker

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-freemarker</artifactId>
</dependency>

6.5.33. Camel Component :: Ftp

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ftp</artifactId>
</dependency>

6.5.34. Camel Component :: Git

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-git</artifactId>
</dependency>

6.5.35. Camel Component :: Github

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-github</artifactId>
</dependency>

6.5.36. Camel Component :: Groovy

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-groovy</artifactId>
</dependency>

6.5.37. Camel Component :: Gson

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-gson</artifactId>
</dependency>

6.5.38. Camel Component :: Hl7

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-hl7</artifactId>
</dependency>

6.5.39. Camel Component :: Http4

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-http4</artifactId>
</dependency>

6.5.40. Camel Component :: Hystrix

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-hystrix</artifactId>
</dependency>

6.5.41. Camel Component :: Infinispan

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-infinispan</artifactId>
</dependency>

6.5.42. Camel Component :: Influxdb

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-influxdb</artifactId>
</dependency>

6.5.43. Camel Component :: Irc

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-irc</artifactId>
</dependency>

6.5.44. Camel Component :: Jackson

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jackson</artifactId>
</dependency>

6.5.45. Camel Component :: Jacksonxml

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jacksonxml</artifactId>
</dependency>

6.5.46. Camel Component :: Jasypt

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jasypt</artifactId>
</dependency>

6.5.47. Camel Component :: Jaxb

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jaxb</artifactId>
</dependency>

6.5.48. Camel Component :: Jbpm

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jbpm</artifactId>
</dependency>

6.5.49. Camel Component :: Jcache

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jcache</artifactId>
</dependency>

6.5.50. Camel Component :: Jdbc

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jdbc</artifactId>
</dependency>

6.5.51. Camel Component :: Jgroups

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jgroups</artifactId>
</dependency>

6.5.52. Camel Component :: Jms

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jms</artifactId>
</dependency>

6.5.53. Camel Component :: Jmx

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jmx</artifactId>
</dependency>

6.5.54. Camel Component :: Jpa

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jpa</artifactId>
</dependency>

6.5.55. Camel Component :: Jsch

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jsch</artifactId>
</dependency>

6.5.56. Camel Component :: Jsonpath

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-jsonpath</artifactId>
</dependency>

6.5.57. Camel Component :: Kafka

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-kafka</artifactId>
</dependency>

6.5.58. Camel Component :: Kubernetes

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-kubernetes</artifactId>
</dependency>

6.5.59. Camel Component :: Ldap

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ldap</artifactId>
</dependency>

6.5.60. Camel Component :: Linkedin

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-linkedin</artifactId>
</dependency>

6.5.61. Camel Component :: Lucene

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-lucene</artifactId>
</dependency>

6.5.62. Camel Component :: Mail

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mail</artifactId>
</dependency>

6.5.63. Camel Component :: Metrics

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-metrics</artifactId>
</dependency>

6.5.64. Camel Component :: Mina2

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mina2</artifactId>
</dependency>

6.5.65. Camel Component :: Mllp

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mllp</artifactId>
</dependency>

6.5.66. Camel Component :: Mongodb

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mongodb</artifactId>
</dependency>

6.5.67. Camel Component :: Mqtt

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mqtt</artifactId>
</dependency>

6.5.68. Camel Component :: Mvel

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mvel</artifactId>
</dependency>

6.5.69. Camel Component :: Mybatis

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-mybatis</artifactId>
</dependency>

6.5.70. Camel Component :: Nats

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-nats</artifactId>
</dependency>

6.5.71. Camel Component :: Netty4

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-netty4</artifactId>
</dependency>

6.5.72. Camel Component :: Ognl

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ognl</artifactId>
</dependency>

6.5.73. Camel Component :: Olingo2

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-olingo2</artifactId>
</dependency>

6.5.74. Camel Component :: Optaplanner

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-optaplanner</artifactId>
</dependency>

6.5.75. Camel Component :: Paho

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-paho</artifactId>
</dependency>

6.5.76. Camel Component :: Pdf

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-pdf</artifactId>
</dependency>

6.5.77. Camel Component :: Protobuf

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-protobuf</artifactId>
</dependency>

6.5.78. Camel Component :: Quartz2

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-quartz2</artifactId>
</dependency>

6.5.79. Camel Component :: Rabbitmq

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-rabbitmq</artifactId>
</dependency>

6.5.80. Camel Component :: Reactive-streams

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-reactive-streams</artifactId>
</dependency>

6.5.81. Camel Component :: Rest-swagger

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-rest-swagger</artifactId>
</dependency>

6.5.82. Camel Component :: Rss

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-rss</artifactId>
</dependency>

6.5.83. Camel Component :: Salesforce

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-salesforce</artifactId>
</dependency>

6.5.84. Camel Component :: Sap-netweaver

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-sap-netweaver</artifactId>
</dependency>

6.5.85. Camel Component :: Saxon

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-saxon</artifactId>
</dependency>

6.5.86. Camel Component :: Schematron

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-schematron</artifactId>
</dependency>

6.5.87. Camel Component :: Script

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-script</artifactId>
</dependency>

6.5.88. Camel Component :: Servicenow

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-servicenow</artifactId>
</dependency>

6.5.89. Camel Component :: Servlet

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-servlet</artifactId>
</dependency>

6.5.90. Camel Component :: Sjms

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-sjms</artifactId>
</dependency>

6.5.91. Camel Component :: Sjms2

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-sjms2</artifactId>
</dependency>

6.5.92. Camel Component :: Smpp

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-smpp</artifactId>
</dependency>

6.5.93. Camel Component :: Snakeyaml

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-snakeyaml</artifactId>
</dependency>

6.5.94. Camel Component :: Snmp

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-snmp</artifactId>
</dependency>

6.5.95. Camel Component :: Soap

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-soap</artifactId>
</dependency>

6.5.96. Camel Component :: Splunk

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-splunk</artifactId>
</dependency>

6.5.97. Camel Component :: Spring-batch

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-spring-batch</artifactId>
</dependency>

6.5.98. Camel Component :: Spring-integration

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-spring-integration</artifactId>
</dependency>

6.5.99. Camel Component :: Spring-ldap

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-spring-ldap</artifactId>
</dependency>

6.5.100. Camel Component :: Spring-redis

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-spring-redis</artifactId>
</dependency>

6.5.101. Camel Component :: Spring-security

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-spring-security</artifactId>
</dependency>

6.5.102. Camel Component :: Sql

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-sql</artifactId>
</dependency>

6.5.103. Camel Component :: Ssh

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-ssh</artifactId>
</dependency>

6.5.104. Camel Component :: Stax

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-stax</artifactId>
</dependency>

6.5.105. Camel Component :: Stream

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-stream</artifactId>
</dependency>

6.5.106. Camel Component :: Swagger

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-swagger</artifactId>
</dependency>

6.5.107. Camel Component :: Syslog

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-syslog</artifactId>
</dependency>

6.5.108. Camel Component :: Tagsoup

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-tagsoup</artifactId>
</dependency>

6.5.109. Camel Component :: Tarfile

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-tarfile</artifactId>
</dependency>

6.5.110. Camel Component :: Twitter

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-twitter</artifactId>
</dependency>

6.5.111. Camel Component :: Undertow

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-undertow</artifactId>
</dependency>

6.5.112. Camel Component :: Velocity

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-velocity</artifactId>
</dependency>

6.5.113. Camel Component :: Vertx

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-vertx</artifactId>
</dependency>

6.5.114. Camel Component :: Weather

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-weather</artifactId>
</dependency>

6.5.115. Camel Component :: Xmlbeans

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-xmlbeans</artifactId>
</dependency>

6.5.116. Camel Component :: Xmlsecurity

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-xmlsecurity</artifactId>
</dependency>

6.5.117. Camel Component :: Xstream

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-xstream</artifactId>
</dependency>

6.5.118. Camel Component :: Zipfile

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-zipfile</artifactId>
</dependency>

6.5.119. Camel Component :: Zipkin

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-zipkin</artifactId>
</dependency>

6.5.120. Camel Component :: Zookeeper

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>camel-zookeeper</artifactId>
</dependency>

6.6. Cassandra

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>cassandra</artifactId>
</dependency>

Configuration

swarm.cassandra.cassandras.KEY.database: Cassandra database name
swarm.cassandra.cassandras.KEY.hosts.KEY.outbound-socket-binding-ref: Cassandra target hostname/port number
swarm.cassandra.cassandras.KEY.id: Unique profile identification
swarm.cassandra.cassandras.KEY.jndi-name: JNDI address
swarm.cassandra.cassandras.KEY.module: Module name
swarm.cassandra.cassandras.KEY.security-domain: Security domain name
swarm.cassandra.cassandras.KEY.ssl: use SSL for connecting to Cassandra

6.7. CDI

Provides context and dependency-injection support according to JSR-299.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>cdi</artifactId>
</dependency>

Configuration

swarm.cdi.development-mode: Weld comes with a special mode for application development. When the development mode is enabled, certain built-in tools, which facilitate the development of CDI applications, are available. Setting this attribute to true activates the development mode.
swarm.cdi.non-portable-mode: If true then the non-portable mode is enabled. The non-portable mode is suggested by the specification to overcome problems with legacy applications that do not use CDI SPI properly and may be rejected by more strict validation in CDI 1.1.
swarm.cdi.require-bean-descriptor: If true then implicit bean archives without bean descriptor file (beans.xml) are ignored by Weld
swarm.cdi.thread-pool-size: The number of threads to be used by the Weld thread pool. The pool is shared across all CDI-enabled deployments and used primarily for parallel Weld bootstrap.

6.7.1. CDI Configuration

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>cdi-config</artifactId>
</dependency>

6.7.2. CDI JAX-RS API Enhancements

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>cdi-jaxrsapi</artifactId>
</dependency>

6.8. JBoss CLI

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>cli</artifactId>
</dependency>

6.9. Connector

Primarily an internal fraction used to provide support for higher-level fractions such as JCA (JSR-322).

If you require JCA support, please see the JCA fraction documentation.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>connector</artifactId>
</dependency>

6.10. Container

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>container</artifactId>
</dependency>

6.11. Datasources

Provides support for container-managed database connections.

6.11.1. Autodetectable drivers

If your application includes the appropriate vendor JDBC library in its normal dependencies, these drivers will be detected and installed by Thorntail without any additional effort.

The list of detectable drivers and their driver-name which may be used when defining a datasource is as follows:

Database driver-name

Database	`driver-name`
MySQL	`mysql`
PostgreSQL	`postgresql`
H2	`h2`
EnterpriseDB	`edb`
IBM DB2	`ibmdb2`
Oracle DB	`oracle`
Microsoft SQLServer	`sqlserver`
Sybase	`sybase`
Teiid	`teiid`
MariaDB	`mariadb`
Derby	`derby`
Hive2	`hive2`
PrestoDB	`prestodb`

MySQL

mysql

PostgreSQL

postgresql

h2

EnterpriseDB

edb

IBM DB2

ibmdb2

Oracle DB

oracle

Microsoft SQLServer

sqlserver

Sybase

sybase

Teiid

teiid

MariaDB

mariadb

Derby

derby

Hive2

hive2

PrestoDB

prestodb

6.11.2. Example datasource definitions

MySQL

An example of a MySQL datasource configuration with connection information, basic security, and validation options:

thorntail:
  datasources:
    data-sources:
      MyDS:
        driver-name: mysql
        connection-url: jdbc:mysql://localhost:3306/jbossdb
        user-name: admin
        password: admin
        valid-connection-checker-class-name: org.jboss.jca.adapters.jdbc.extensions.mysql.MySQLValidConnectionChecker
        validate-on-match: true
        background-validation: false
        exception-sorter-class-name: org.jboss.jca.adapters.jdbc.extensions.mysql.MySQLExceptionSorter

PostgreSQL

An example of a PostgreSQL datasource configuration with connection information, basic security, and validation options:

thorntail:
  datasources:
    data-sources:
      MyDS:
        driver-name: postgresql
        connection-url: jdbc:postgresql://localhost:5432/postgresdb
        user-name: admin
        password: admin
        valid-connection-checker-class-name: org.jboss.jca.adapters.jdbc.extensions.postgres.PostgreSQLValidConnectionChecker
        validate-on-match: true
        background-validation: false
        exception-sorter-class-name: org.jboss.jca.adapters.jdbc.extensions.postgres.PostgreSQLExceptionSorter

Oracle

An example of an Oracle datasource configuration with connection information, basic security, and validation options:

thorntail:
  datasources:
    data-sources:
      MyDS:
        driver-name: oracle
        connection-url: jdbc:oracle:thin:@localhost:1521:XE
        user-name: admin
        password: admin
        valid-connection-checker-class-name: org.jboss.jca.adapters.jdbc.extensions.oracle.OracleValidConnectionChecker
        validate-on-match: true
        background-validation: false
        stale-connection-checker-class-name: org.jboss.jca.adapters.jdbc.extensions.oracle.OracleStaleConnectionChecker
        exception-sorter-class-name: org.jboss.jca.adapters.jdbc.extensions.oracle.OracleExceptionSorter

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>datasources</artifactId>
</dependency>

Configuration

swarm.datasources.data-sources.KEY.allocation-retry: The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception
swarm.datasources.data-sources.KEY.allocation-retry-wait-millis: The allocation retry wait millis element specifies the amount of time, in milliseconds, to wait between retrying to allocate a connection
swarm.datasources.data-sources.KEY.allow-multiple-users: Specifies if multiple users will access the datasource through the getConnection(user, password) method and hence if the internal pool type should account for that
swarm.datasources.data-sources.KEY.authentication-context: The Elytron authentication context which defines the javax.security.auth.Subject that is used to distinguish connections in the pool.
swarm.datasources.data-sources.KEY.background-validation: An element to specify that connections should be validated on a background thread versus being validated prior to use. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
swarm.datasources.data-sources.KEY.background-validation-millis: The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run. Changing this value can be done only on disabled datasource, requires a server restart otherwise
swarm.datasources.data-sources.KEY.blocking-timeout-wait-millis: The blocking-timeout-millis element specifies the maximum time, in milliseconds, to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for locking a connection, and will never throw an exception if creating a new connection takes an inordinately long time
swarm.datasources.data-sources.KEY.capacity-decrementer-class: Class defining the policy for decrementing connections in the pool
swarm.datasources.data-sources.KEY.capacity-decrementer-properties: Properties to be injected in class defining the policy for decrementing connections in the pool
swarm.datasources.data-sources.KEY.capacity-incrementer-class: Class defining the policy for incrementing connections in the pool
swarm.datasources.data-sources.KEY.capacity-incrementer-properties: Properties to be injected in class defining the policy for incrementing connections in the pool
swarm.datasources.data-sources.KEY.check-valid-connection-sql: Specify an SQL statement to check validity of a pool connection. This may be called when managed connection is obtained from the pool
swarm.datasources.data-sources.KEY.connectable: Enable the use of CMR. This feature means that a local resource can reliably participate in an XA transaction.
swarm.datasources.data-sources.KEY.connection-listener-class: Speciefies class name extending org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that provides a possible to listen for connection activation and passivation in order to perform actions before the connection is returned to the application or returned to the pool.
swarm.datasources.data-sources.KEY.connection-listener-property: Properties to be injected in class specidied in connection-listener-class
swarm.datasources.data-sources.KEY.connection-properties.KEY.value: Each connection-property specifies a string name/value pair with the property name coming from the name attribute and the value coming from the element content
swarm.datasources.data-sources.KEY.connection-url: The JDBC driver connection URL
swarm.datasources.data-sources.KEY.credential-reference: Credential (from Credential Store) to authenticate on data source
swarm.datasources.data-sources.KEY.datasource-class: The fully qualified name of the JDBC datasource class
swarm.datasources.data-sources.KEY.driver-class: The fully qualified name of the JDBC driver class
swarm.datasources.data-sources.KEY.driver-name: Defines the JDBC driver the datasource should use. It is a symbolic name matching the the name of installed driver. In case the driver is deployed as jar, the name is the name of deployment unit
swarm.datasources.data-sources.KEY.elytron-enabled: Enables Elytron security for handling authentication of connections. The Elytron authentication-context to be used will be current context if no context is specified (see authentication-context).
swarm.datasources.data-sources.KEY.enlistment-trace: Defines if WildFly/IronJacamar should record enlistment traces
swarm.datasources.data-sources.KEY.exception-sorter-class-name: An org.jboss.jca.adapters.jdbc.ExceptionSorter that provides an isExceptionFatal(SQLException) method to validate if an exception should broadcast an error
swarm.datasources.data-sources.KEY.exception-sorter-properties: The exception sorter properties
swarm.datasources.data-sources.KEY.flush-strategy: Specifies how the pool should be flush in case of an error.
swarm.datasources.data-sources.KEY.idle-timeout-minutes: The idle-timeout-minutes elements specifies the maximum time, in minutes, a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is half of the smallest idle-timeout-minutes value of any pool. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
swarm.datasources.data-sources.KEY.initial-pool-size: The initial-pool-size element indicates the initial number of connections a pool should hold.
swarm.datasources.data-sources.KEY.jndi-name: Specifies the JNDI name for the datasource
swarm.datasources.data-sources.KEY.jta: Enable JTA integration
swarm.datasources.data-sources.KEY.max-pool-size: The max-pool-size element specifies the maximum number of connections for a pool. No more connections will be created in each sub-pool
swarm.datasources.data-sources.KEY.mcp: Defines the ManagedConnectionPool implementation, f.ex. org.jboss.jca.core.connectionmanager.pool.mcp.SemaphoreArrayListManagedConnectionPool
swarm.datasources.data-sources.KEY.min-pool-size: The min-pool-size element specifies the minimum number of connections for a pool
swarm.datasources.data-sources.KEY.new-connection-sql: Specifies an SQL statement to execute whenever a connection is added to the connection pool
swarm.datasources.data-sources.KEY.password: Specifies the password used when creating a new connection
swarm.datasources.data-sources.KEY.pool-fair: Defines if pool use should be fair
swarm.datasources.data-sources.KEY.pool-prefill: Should the pool be prefilled. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
swarm.datasources.data-sources.KEY.pool-use-strict-min: Specifies if the min-pool-size should be considered strictly
swarm.datasources.data-sources.KEY.prepared-statements-cache-size: The number of prepared statements per connection in an LRU cache
swarm.datasources.data-sources.KEY.query-timeout: Any configured query timeout in seconds. If not provided no timeout will be set
swarm.datasources.data-sources.KEY.reauth-plugin-class-name: The fully qualified class name of the reauthentication plugin implementation
swarm.datasources.data-sources.KEY.reauth-plugin-properties: The properties for the reauthentication plugin
swarm.datasources.data-sources.KEY.security-domain: Specifies the PicketBox security domain which defines the PicketBox javax.security.auth.Subject that are used to distinguish connections in the pool
swarm.datasources.data-sources.KEY.set-tx-query-timeout: Whether to set the query timeout based on the time remaining until transaction timeout. Any configured query timeout will be used if there is no transaction
swarm.datasources.data-sources.KEY.share-prepared-statements: Whether to share prepared statements, i.e. whether asking for same statement twice without closing uses the same underlying prepared statement
swarm.datasources.data-sources.KEY.spy: Enable spying of SQL statements
swarm.datasources.data-sources.KEY.stale-connection-checker-class-name: An org.jboss.jca.adapters.jdbc.StaleConnectionChecker that provides an isStaleConnection(SQLException) method which if it returns true will wrap the exception in an org.jboss.jca.adapters.jdbc.StaleConnectionException
swarm.datasources.data-sources.KEY.stale-connection-checker-properties: The stale connection checker properties
swarm.datasources.data-sources.KEY.statistics-enabled: Define whether runtime statistics are enabled or not.
swarm.datasources.data-sources.KEY.track-statements: Whether to check for unclosed statements when a connection is returned to the pool, result sets are closed, a statement is closed or return to the prepared statement cache. Valid values are: "false" - do not track statements, "true" - track statements and result sets and warn when they are not closed, "nowarn" - track statements but do not warn about them being unclosed
swarm.datasources.data-sources.KEY.tracking: Defines if IronJacamar should track connection handles across transaction boundaries
swarm.datasources.data-sources.KEY.transaction-isolation: Set the java.sql.Connection transaction isolation level. Valid values are: TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE and TRANSACTION_NONE. Different values are used to set customLevel using TransactionIsolation#customLevel
swarm.datasources.data-sources.KEY.url-delimiter: Specifies the delimiter for URLs in connection-url for HA datasources
swarm.datasources.data-sources.KEY.url-selector-strategy-class-name: A class that implements org.jboss.jca.adapters.jdbc.URLSelectorStrategy
swarm.datasources.data-sources.KEY.use-ccm: Enable the use of a cached connection manager
swarm.datasources.data-sources.KEY.use-fast-fail: Whether to fail a connection allocation on the first try if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false)
swarm.datasources.data-sources.KEY.use-java-context: Setting this to false will bind the datasource into global JNDI
swarm.datasources.data-sources.KEY.use-try-lock: Any configured timeout for internal locks on the resource adapter objects in seconds
swarm.datasources.data-sources.KEY.user-name: Specify the user name used when creating a new connection
swarm.datasources.data-sources.KEY.valid-connection-checker-class-name: An org.jboss.jca.adapters.jdbc.ValidConnectionChecker that provides an isValidConnection(Connection) method to validate a connection. If an exception is returned that means the connection is invalid. This overrides the check-valid-connection-sql element
swarm.datasources.data-sources.KEY.valid-connection-checker-properties: The valid connection checker properties
swarm.datasources.data-sources.KEY.validate-on-match: The validate-on-match element specifies if connection validation should be done when a connection factory attempts to match a managed connection. This is typically exclusive to the use of background validation
swarm.datasources.installed-drivers: List of JDBC drivers that have been installed in the runtime
swarm.datasources.jdbc-drivers.KEY.deployment-name: The name of the deployment unit from which the driver was loaded
swarm.datasources.jdbc-drivers.KEY.driver-class-name: The fully qualified class name of the java.sql.Driver implementation
swarm.datasources.jdbc-drivers.KEY.driver-datasource-class-name: The fully qualified class name of the javax.sql.DataSource implementation
swarm.datasources.jdbc-drivers.KEY.driver-major-version: The driver’s major version number
swarm.datasources.jdbc-drivers.KEY.driver-minor-version: The driver’s minor version number
swarm.datasources.jdbc-drivers.KEY.driver-module-name: The name of the module from which the driver was loaded, if it was loaded from the module path
swarm.datasources.jdbc-drivers.KEY.driver-name: Defines the JDBC driver the datasource should use. It is a symbolic name matching the the name of installed driver. In case the driver is deployed as jar, the name is the name of deployment unit
swarm.datasources.jdbc-drivers.KEY.driver-xa-datasource-class-name: The fully qualified class name of the javax.sql.XADataSource implementation
swarm.datasources.jdbc-drivers.KEY.jdbc-compliant: Whether or not the driver is JDBC compliant
swarm.datasources.jdbc-drivers.KEY.module-slot: The slot of the module from which the driver was loaded, if it was loaded from the module path
swarm.datasources.jdbc-drivers.KEY.profile: Domain Profile in which driver is defined. Null in case of standalone server
swarm.datasources.jdbc-drivers.KEY.xa-datasource-class: XA datasource class
swarm.datasources.xa-data-sources.KEY.allocation-retry: The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception
swarm.datasources.xa-data-sources.KEY.allocation-retry-wait-millis: The allocation retry wait millis element specifies the amount of time, in milliseconds, to wait between retrying to allocate a connection
swarm.datasources.xa-data-sources.KEY.allow-multiple-users: Specifies if multiple users will access the datasource through the getConnection(user, password) method and hence if the internal pool type should account for that
swarm.datasources.xa-data-sources.KEY.authentication-context: The Elytron authentication context which defines the javax.security.auth.Subject that is used to distinguish connections in the pool.
swarm.datasources.xa-data-sources.KEY.background-validation: An element to specify that connections should be validated on a background thread versus being validated prior to use.
swarm.datasources.xa-data-sources.KEY.background-validation-millis: The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run.
swarm.datasources.xa-data-sources.KEY.blocking-timeout-wait-millis: The blocking-timeout-millis element specifies the maximum time, in milliseconds, to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for locking a connection, and will never throw an exception if creating a new connection takes an inordinately long time
swarm.datasources.xa-data-sources.KEY.capacity-decrementer-class: Class defining the policy for decrementing connections in the pool
swarm.datasources.xa-data-sources.KEY.capacity-decrementer-properties: Properties to inject in class defining the policy for decrementing connections in the pool
swarm.datasources.xa-data-sources.KEY.capacity-incrementer-class: Class defining the policy for incrementing connections in the pool
swarm.datasources.xa-data-sources.KEY.capacity-incrementer-properties: Properties to inject in class defining the policy for incrementing connections in the pool
swarm.datasources.xa-data-sources.KEY.check-valid-connection-sql: Specify an SQL statement to check validity of a pool connection. This may be called when managed connection is obtained from the pool
swarm.datasources.xa-data-sources.KEY.connectable: Enable the use of CMR for this datasource. This feature means that a local resource can reliably participate in an XA transaction.
swarm.datasources.xa-data-sources.KEY.connection-listener-class: Speciefies class name extending org.jboss.jca.adapters.jdbc.spi.listener.ConnectionListener that provides a possible to listen for connection activation and passivation in order to perform actions before the connection is returned to the application or returned to the pool.
swarm.datasources.xa-data-sources.KEY.connection-listener-property: Properties to be injected in class specified in connection-listener-class
swarm.datasources.xa-data-sources.KEY.credential-reference: Credential (from Credential Store) to authenticate on data source
swarm.datasources.xa-data-sources.KEY.driver-name: Defines the JDBC driver the datasource should use. It is a symbolic name matching the the name of installed driver. In case the driver is deployed as jar, the name is the name of deployment unit
swarm.datasources.xa-data-sources.KEY.elytron-enabled: Enables Elytron security for handling authentication of connections for recovery. The Elytron authentication-context to be used will be current context if no context is specified (see authentication-context).
swarm.datasources.xa-data-sources.KEY.enlistment-trace: Defines if WildFly/IronJacamar should record enlistment traces
swarm.datasources.xa-data-sources.KEY.exception-sorter-class-name: An org.jboss.jca.adapters.jdbc.ExceptionSorter that provides an isExceptionFatal(SQLException) method to validate if an exception should broadcast an error
swarm.datasources.xa-data-sources.KEY.exception-sorter-properties: The exception sorter properties
swarm.datasources.xa-data-sources.KEY.flush-strategy: Specifies how the pool should be flush in case of an error.
swarm.datasources.xa-data-sources.KEY.idle-timeout-minutes: The idle-timeout-minutes elements specifies the maximum time, in minutes, a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is half of the smallest idle-timeout-minutes value of any pool. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
swarm.datasources.xa-data-sources.KEY.initial-pool-size: The initial-pool-size element indicates the initial number of connections a pool should hold.
swarm.datasources.xa-data-sources.KEY.interleaving: An element to enable interleaving for XA connections
swarm.datasources.xa-data-sources.KEY.jndi-name: Specifies the JNDI name for the datasource
swarm.datasources.xa-data-sources.KEY.max-pool-size: The max-pool-size element specifies the maximum number of connections for a pool. No more connections will be created in each sub-pool
swarm.datasources.xa-data-sources.KEY.mcp: Defines the ManagedConnectionPool implementation, f.ex. org.jboss.jca.core.connectionmanager.pool.mcp.SemaphoreArrayListManagedConnectionPool
swarm.datasources.xa-data-sources.KEY.min-pool-size: The min-pool-size element specifies the minimum number of connections for a pool
swarm.datasources.xa-data-sources.KEY.new-connection-sql: Specifies an SQL statement to execute whenever a connection is added to the connection pool
swarm.datasources.xa-data-sources.KEY.no-recovery: Specifies if the connection pool should be excluded from recovery
swarm.datasources.xa-data-sources.KEY.no-tx-separate-pool: Oracle does not like XA connections getting used both inside and outside a JTA transaction. To workaround the problem you can create separate sub-pools for the different contexts
swarm.datasources.xa-data-sources.KEY.pad-xid: Should the Xid be padded
swarm.datasources.xa-data-sources.KEY.password: Specifies the password used when creating a new connection
swarm.datasources.xa-data-sources.KEY.pool-fair: Defines if pool use should be fair
swarm.datasources.xa-data-sources.KEY.pool-prefill: Should the pool be prefilled. Changing this value can be done only on disabled datasource, requires a server restart otherwise.
swarm.datasources.xa-data-sources.KEY.pool-use-strict-min: Specifies if the min-pool-size should be considered strictly
swarm.datasources.xa-data-sources.KEY.prepared-statements-cache-size: The number of prepared statements per connection in an LRU cache
swarm.datasources.xa-data-sources.KEY.query-timeout: Any configured query timeout in seconds. If not provided no timeout will be set
swarm.datasources.xa-data-sources.KEY.reauth-plugin-class-name: The fully qualified class name of the reauthentication plugin implementation
swarm.datasources.xa-data-sources.KEY.reauth-plugin-properties: The properties for the reauthentication plugin
swarm.datasources.xa-data-sources.KEY.recovery-authentication-context: The Elytron authentication context which defines the javax.security.auth.Subject that is used to distinguish connections in the pool.
swarm.datasources.xa-data-sources.KEY.recovery-credential-reference: Credential (from Credential Store) to authenticate on data source
swarm.datasources.xa-data-sources.KEY.recovery-elytron-enabled: Enables Elytron security for handling authentication of connections for recovery. The Elytron authentication-context to be used will be current context if no context is specified (see authentication-context).
swarm.datasources.xa-data-sources.KEY.recovery-password: The password used for recovery
swarm.datasources.xa-data-sources.KEY.recovery-plugin-class-name: The fully qualified class name of the recovery plugin implementation
swarm.datasources.xa-data-sources.KEY.recovery-plugin-properties: The properties for the recovery plugin
swarm.datasources.xa-data-sources.KEY.recovery-security-domain: The security domain used for recovery
swarm.datasources.xa-data-sources.KEY.recovery-username: The user name used for recovery
swarm.datasources.xa-data-sources.KEY.same-rm-override: The is-same-rm-override element allows one to unconditionally set whether the javax.transaction.xa.XAResource.isSameRM(XAResource) returns true or false
swarm.datasources.xa-data-sources.KEY.security-domain: Specifies the PicketBox security domain which defines the javax.security.auth.Subject that are used to distinguish connections in the pool
swarm.datasources.xa-data-sources.KEY.set-tx-query-timeout: Whether to set the query timeout based on the time remaining until transaction timeout. Any configured query timeout will be used if there is no transaction
swarm.datasources.xa-data-sources.KEY.share-prepared-statements: Whether to share prepared statements, i.e. whether asking for same statement twice without closing uses the same underlying prepared statement
swarm.datasources.xa-data-sources.KEY.spy: Enable spying of SQL statements
swarm.datasources.xa-data-sources.KEY.stale-connection-checker-class-name: An org.jboss.jca.adapters.jdbc.StaleConnectionChecker that provides an isStaleConnection(SQLException) method which if it returns true will wrap the exception in an org.jboss.jca.adapters.jdbc.StaleConnectionException
swarm.datasources.xa-data-sources.KEY.stale-connection-checker-properties: The stale connection checker properties
swarm.datasources.xa-data-sources.KEY.statistics-enabled: Define whether runtime statistics are enabled or not.
swarm.datasources.xa-data-sources.KEY.track-statements: Whether to check for unclosed statements when a connection is returned to the pool, result sets are closed, a statement is closed or return to the prepared statement cache. Valid values are: "false" - do not track statements, "true" - track statements and result sets and warn when they are not closed, "nowarn" - track statements but do not warn about them being unclosed
swarm.datasources.xa-data-sources.KEY.tracking: Defines if IronJacamar should track connection handles across transaction boundaries
swarm.datasources.xa-data-sources.KEY.transaction-isolation: Set the java.sql.Connection transaction isolation level. Valid values are: TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE and TRANSACTION_NONE. Different values are used to set customLevel using TransactionIsolation#customLevel.
swarm.datasources.xa-data-sources.KEY.url-delimiter: Specifies the delimiter for URLs in connection-url for HA datasources
swarm.datasources.xa-data-sources.KEY.url-property: Specifies the property for the URL property in the xa-datasource-property values
swarm.datasources.xa-data-sources.KEY.url-selector-strategy-class-name: A class that implements org.jboss.jca.adapters.jdbc.URLSelectorStrategy
swarm.datasources.xa-data-sources.KEY.use-ccm: Enable the use of a cached connection manager
swarm.datasources.xa-data-sources.KEY.use-fast-fail: Whether to fail a connection allocation on the first try if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false)
swarm.datasources.xa-data-sources.KEY.use-java-context: Setting this to false will bind the datasource into global JNDI
swarm.datasources.xa-data-sources.KEY.use-try-lock: Any configured timeout for internal locks on the resource adapter objects in seconds
swarm.datasources.xa-data-sources.KEY.user-name: Specify the user name used when creating a new connection
swarm.datasources.xa-data-sources.KEY.valid-connection-checker-class-name: An org.jboss.jca.adapters.jdbc.ValidConnectionChecker that provides an isValidConnection(Connection) method to validate a connection. If an exception is returned that means the connection is invalid. This overrides the check-valid-connection-sql element
swarm.datasources.xa-data-sources.KEY.valid-connection-checker-properties: The valid connection checker properties
swarm.datasources.xa-data-sources.KEY.validate-on-match: The validate-on-match element specifies if connection validation should be done when a connection factory attempts to match a managed connection. This is typically exclusive to the use of background validation
swarm.datasources.xa-data-sources.KEY.wrap-xa-resource: Should the XAResource instances be wrapped in an org.jboss.tm.XAResourceWrapper instance
swarm.datasources.xa-data-sources.KEY.xa-datasource-class: The fully qualified name of the javax.sql.XADataSource implementation
swarm.datasources.xa-data-sources.KEY.xa-datasource-properties.KEY.value: Specifies a property value to assign to the XADataSource implementation class. Each property is identified by the name attribute and the property value is given by the xa-datasource-property element content. The property is mapped onto the XADataSource implementation by looking for a JavaBeans style getter method for the property name. If found, the value of the property is set using the JavaBeans setter with the element text translated to the true property type using the java.beans.PropertyEditor
swarm.datasources.xa-data-sources.KEY.xa-resource-timeout: The value is passed to XAResource.setTransactionTimeout(), in seconds. Default is zero
thorntail.ds.connection.url: Default datasource connection URL
thorntail.ds.name: Name of the default datasource
thorntail.ds.password: Defatul datasource connection password
thorntail.ds.username: Default datasource connection user name
thorntail.jdbc.driver: Defatul datasource JDBC driver name

6.12. Drools Server

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>drools-server</artifactId>
</dependency>

6.13. EE

An internal fraction used to support other higher-level fractions.

The EE fraction does not imply the totality of Java EE support.

If you require specific Java EE technologies, address them individually, for example jaxrs, cdi, datasources, or ejb.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>ee</artifactId>
</dependency>

Configuration

swarm.ee.annotation-property-replacement: Flag indicating whether Java EE annotations will have property replacements applied
swarm.ee.context-services.KEY.jndi-name: The JNDI Name to lookup the context service.
swarm.ee.context-services.KEY.use-transaction-setup-provider: Flag which indicates if the transaction setup provider should be used
swarm.ee.default-bindings-service.context-service: The JNDI name where the default EE Context Service can be found
swarm.ee.default-bindings-service.datasource: The JNDI name where the default EE Datasource can be found
swarm.ee.default-bindings-service.jms-connection-factory: The JNDI name where the default EE JMS Connection Factory can be found
swarm.ee.default-bindings-service.managed-executor-service: The JNDI name where the default EE Managed Executor Service can be found
swarm.ee.default-bindings-service.managed-scheduled-executor-service: The JNDI name where the default EE Managed Scheduled Executor Service can be found
swarm.ee.default-bindings-service.managed-thread-factory: The JNDI name where the default EE Managed Thread Factory can be found
swarm.ee.ear-subdeployments-isolated: Flag indicating whether each of the subdeployments within a .ear can access classes belonging to another subdeployment within the same .ear. A value of false means the subdeployments can see classes belonging to other subdeployments within the .ear.
swarm.ee.global-modules: A list of modules that should be made available to all deployments.
swarm.ee.jboss-descriptor-property-replacement: Flag indicating whether JBoss specific deployment descriptors will have property replacements applied
swarm.ee.managed-executor-services.KEY.context-service: The name of the context service to be used by the executor.
swarm.ee.managed-executor-services.KEY.core-threads: The minimum number of threads to be used by the executor. If left undefined the default core-size is calculated based on the number of processors. A value of zero is not advised and in some cases invalid. See the queue-length attribute for details on how this value is used to determine the queuing strategy.
swarm.ee.managed-executor-services.KEY.hung-task-threshold: The runtime, in milliseconds, for tasks to be considered hung by the managed executor service. If value is 0 tasks are never considered hung.
swarm.ee.managed-executor-services.KEY.jndi-name: The JNDI Name to lookup the managed executor service.
swarm.ee.managed-executor-services.KEY.keepalive-time: When the number of threads is greater than the core, this is the maximum time, in milliseconds, that excess idle threads will wait for new tasks before terminating.
swarm.ee.managed-executor-services.KEY.long-running-tasks: Flag which hints the duration of tasks executed by the executor.
swarm.ee.managed-executor-services.KEY.max-threads: The maximum number of threads to be used by the executor. If left undefined the value from core-size will be used. This value is ignored if an unbounded queue is used (only core-threads will be used in that case).
swarm.ee.managed-executor-services.KEY.queue-length: The executors task queue capacity. A length of 0 means direct hand-off and possible rejection will occur. An undefined length (the default), or Integer.MAX_VALUE, indicates that an unbounded queue should be used. All other values specify an exact queue size. If an unbounded queue or direct hand-off is used, a core-threads value greater than zero is required.
swarm.ee.managed-executor-services.KEY.reject-policy: The policy to be applied to aborted tasks.
swarm.ee.managed-executor-services.KEY.thread-factory: The name of the thread factory to be used by the executor.
swarm.ee.managed-scheduled-executor-services.KEY.context-service: The name of the context service to be used by the scheduled executor.
swarm.ee.managed-scheduled-executor-services.KEY.core-threads: The minimum number of threads to be used by the scheduled executor.
swarm.ee.managed-scheduled-executor-services.KEY.hung-task-threshold: The runtime, in milliseconds, for tasks to be considered hung by the scheduled executor. If 0 tasks are never considered hung.
swarm.ee.managed-scheduled-executor-services.KEY.jndi-name: The JNDI Name to lookup the managed scheduled executor service.
swarm.ee.managed-scheduled-executor-services.KEY.keepalive-time: When the number of threads is greater than the core, this is the maximum time, in milliseconds, that excess idle threads will wait for new tasks before terminating.
swarm.ee.managed-scheduled-executor-services.KEY.long-running-tasks: Flag which hints the duration of tasks executed by the scheduled executor.
swarm.ee.managed-scheduled-executor-services.KEY.reject-policy: The policy to be applied to aborted tasks.
swarm.ee.managed-scheduled-executor-services.KEY.thread-factory: The name of the thread factory to be used by the scheduled executor.
swarm.ee.managed-thread-factories.KEY.context-service: The name of the context service to be used by the managed thread factory
swarm.ee.managed-thread-factories.KEY.jndi-name: The JNDI Name to lookup the managed thread factory.
swarm.ee.managed-thread-factories.KEY.priority: The priority applied to threads created by the factory
swarm.ee.spec-descriptor-property-replacement: Flag indicating whether descriptors defined by the Java EE specification will have property replacements applied

6.14. EJB

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>ejb</artifactId>
</dependency>

Configuration

thorntail.ejb3.allow-ejb-name-regex: If this is true then regular expressions can be used in interceptor bindings to allow interceptors to be mapped to all beans that match the regular expression
thorntail.ejb3.application-security-domains.KEY.enable-jacc: Enable authorization using JACC
thorntail.ejb3.application-security-domains.KEY.referencing-deployments: The deployments currently referencing this mapping
thorntail.ejb3.application-security-domains.KEY.security-domain: The Elytron security domain to be used by deployments that reference the mapped security domain
thorntail.ejb3.async-service.thread-pool-name: The name of the thread pool which handles asynchronous invocations
thorntail.ejb3.caches.KEY.aliases: The aliases by which this cache may also be referenced
thorntail.ejb3.caches.KEY.passivation-store: The passivation store used by this cache
thorntail.ejb3.cluster-passivation-stores.KEY.bean-cache: The name of the cache used to store bean instances.
thorntail.ejb3.cluster-passivation-stores.KEY.cache-container: The name of the cache container used for the bean and client-mappings caches
thorntail.ejb3.cluster-passivation-stores.KEY.idle-timeout: The timeout in units specified by idle-timeout-unit, after which a bean will passivate
thorntail.ejb3.cluster-passivation-stores.KEY.max-size: The maximum number of beans this cache should store before forcing old beans to passivate
thorntail.ejb3.default-clustered-sfsb-cache: Name of the default stateful bean cache, which will be applicable to all clustered stateful EJBs, unless overridden at the deployment or bean level
thorntail.ejb3.default-distinct-name: The default distinct name that is applied to every EJB deployed on this server
thorntail.ejb3.default-entity-bean-instance-pool: Name of the default entity bean instance pool, which will be applicable to all entity beans, unless overridden at the deployment or bean level
thorntail.ejb3.default-entity-bean-optimistic-locking: If set to true entity beans will use optimistic locking by default
thorntail.ejb3.default-mdb-instance-pool: Name of the default MDB instance pool, which will be applicable to all MDBs, unless overridden at the deployment or bean level
thorntail.ejb3.default-missing-method-permissions-deny-access: If this is set to true then methods on an EJB with a security domain specified or with other methods with security metadata will have an implicit @DenyAll unless other security metadata is present
thorntail.ejb3.default-resource-adapter-name: Name of the default resource adapter name that will be used by MDBs, unless overridden at the deployment or bean level
thorntail.ejb3.default-security-domain: The default security domain that will be used for EJBs if the bean doesn’t explicitly specify one
thorntail.ejb3.default-sfsb-cache: Name of the default stateful bean cache, which will be applicable to all stateful EJBs, unless overridden at the deployment or bean level
thorntail.ejb3.default-sfsb-passivation-disabled-cache: Name of the default stateful bean cache, which will be applicable to all stateful EJBs which have passivation disabled. Each deployment or EJB can optionally override this cache name.
thorntail.ejb3.default-singleton-bean-access-timeout: The default access timeout for singleton beans
thorntail.ejb3.default-slsb-instance-pool: Name of the default stateless bean instance pool, which will be applicable to all stateless EJBs, unless overridden at the deployment or bean level
thorntail.ejb3.default-stateful-bean-access-timeout: The default access timeout for stateful beans
thorntail.ejb3.disable-default-ejb-permissions: This deprecated attribute has no effect and will be removed in a future release; it may never be set to a "false" value
thorntail.ejb3.enable-graceful-txn-shutdown: Enabling txn graceful shutdown will make the server wait for active EJB-related transactions to complete before suspending. For that reason, if the server is running on a cluster, the suspending cluster node may receive ejb requests until all active transactions are complete. To avoid this behavior, omit this tag.
thorntail.ejb3.enable-statistics: If set to true, enable the collection of invocation statistics. Deprecated in favour of "statistics-enabled"
thorntail.ejb3.file-passivation-stores.KEY.idle-timeout: The timeout in units specified by idle-timeout-unit, after which a bean will passivate
thorntail.ejb3.file-passivation-stores.KEY.max-size: The maximum number of beans this cache should store before forcing old beans to passivate
thorntail.ejb3.identity-service.outflow-security-domains: References to security domains to attempt to outflow any established identity to
thorntail.ejb3.iiop-service.enable-by-default: If this is true EJB’s will be exposed over IIOP by default, otherwise it needs to be explicitly enabled in the deployment descriptor
thorntail.ejb3.iiop-service.use-qualified-name: If true EJB names will be bound into the naming service with the application and module name prepended to the name (e.g. myapp/mymodule/MyEjb)
thorntail.ejb3.in-vm-remote-interface-invocation-pass-by-value: If set to false, the parameters to invocations on remote interface of an EJB, will be passed by reference. Else, the parameters will be passed by value.
thorntail.ejb3.log-system-exceptions: If this is true then all EJB system (not application) exceptions will be logged. The EJB spec mandates this behaviour, however it is not recommended as it will often result in exceptions being logged twice (once by the EJB and once by the calling code)
thorntail.ejb3.mdb-delivery-groups.KEY.active: Indicates if delivery for all MDBs belonging to this group is active
thorntail.ejb3.passivation-stores.KEY.bean-cache: The name of the cache used to store bean instances.
thorntail.ejb3.passivation-stores.KEY.cache-container: The name of the cache container used for the bean and client-mappings caches
thorntail.ejb3.passivation-stores.KEY.max-size: The maximum number of beans this cache should store before forcing old beans to passivate
thorntail.ejb3.remote-service.channel-creation-options.KEY.type: The type of the channel creation option
thorntail.ejb3.remote-service.channel-creation-options.KEY.value: The value for the EJB remote channel creation option
thorntail.ejb3.remote-service.cluster: The name of the clustered cache container which will be used to store/access the client-mappings of the EJB remoting connector’s socket-binding on each node, in the cluster
thorntail.ejb3.remote-service.connector-ref: The name of the connector on which the EJB3 remoting channel is registered
thorntail.ejb3.remote-service.execute-in-worker: If this is true the EJB request will be executed in the IO subsystems worker, otherwise it will dispatch to the EJB thread pool
thorntail.ejb3.remote-service.thread-pool-name: The name of the thread pool that handles remote invocations
thorntail.ejb3.remoting-profiles.KEY.exclude-local-receiver: If set no local receiver is used in this profile
thorntail.ejb3.remoting-profiles.KEY.local-receiver-pass-by-value: If set local receiver will pass ejb beans by value
thorntail.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.channel-creation-options.KEY.type: The type of the channel creation option
thorntail.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.channel-creation-options.KEY.value: The value for the EJB remote channel creation option
thorntail.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.connect-timeout: Remoting ejb receiver connect timeout
thorntail.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.outbound-connection-ref: Name of outbound connection that will be used by the ejb receiver
thorntail.ejb3.remoting-profiles.KEY.static-ejb-discovery: Describes static discovery config for EJB’s
thorntail.ejb3.statistics-enabled: If set to true, enable the collection of invocation statistics.
thorntail.ejb3.strict-max-bean-instance-pools.KEY.derive-size: Specifies if and what the max pool size should be derived from. An undefined value (or the deprecated value 'none' which is converted to undefined) indicates that the explicit value of max-pool-size should be used. A value of 'from-worker-pools' indicates that the max pool size should be derived from the size of the total threads for all worker pools configured on the system. A value of 'from-cpu-count' indicates that the max pool size should be derived from the total number of processors available on the system. Note that the computation isn’t a 1:1 mapping, the values may or may not be augmented by other factors.
thorntail.ejb3.strict-max-bean-instance-pools.KEY.max-pool-size: The maximum number of bean instances that the pool can hold at a given point in time
thorntail.ejb3.strict-max-bean-instance-pools.KEY.timeout: The maximum amount of time to wait for a bean instance to be available from the pool
thorntail.ejb3.strict-max-bean-instance-pools.KEY.timeout-unit: The instance acquisition timeout unit
thorntail.ejb3.thread-pools.KEY.active-count: The approximate number of threads that are actively executing tasks.
thorntail.ejb3.thread-pools.KEY.completed-task-count: The approximate total number of tasks that have completed execution.
thorntail.ejb3.thread-pools.KEY.current-thread-count: The current number of threads in the pool.
thorntail.ejb3.thread-pools.KEY.keepalive-time: Used to specify the amount of time that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
thorntail.ejb3.thread-pools.KEY.largest-thread-count: The largest number of threads that have ever simultaneously been in the pool.
thorntail.ejb3.thread-pools.KEY.max-threads: The maximum thread pool size.
thorntail.ejb3.thread-pools.KEY.name: The name of the thread pool.
thorntail.ejb3.thread-pools.KEY.queue-size: The queue size.
thorntail.ejb3.thread-pools.KEY.rejected-count: The number of tasks that have been rejected.
thorntail.ejb3.thread-pools.KEY.task-count: The approximate total number of tasks that have ever been scheduled for execution.
thorntail.ejb3.thread-pools.KEY.thread-factory: Specifies the name of a specific thread factory to use to create worker threads. If not defined an appropriate default thread factory will be used.
thorntail.ejb3.timer-service.database-data-stores.KEY.allow-execution: If this node is allowed to execute timers. If this is false then the timers will be added to the database, and another node may execute them. Note that depending on your refresh interval if you add timers with a very short delay they will not be executed until another node refreshes.
thorntail.ejb3.timer-service.database-data-stores.KEY.database: The type of database that is in use. SQL can be customised per database type.
thorntail.ejb3.timer-service.database-data-stores.KEY.datasource-jndi-name: The datasource that is used to persist the timers
thorntail.ejb3.timer-service.database-data-stores.KEY.partition: The partition name. This should be set to a different value for every node that is sharing a database to prevent the same timer being loaded by multiple noded.
thorntail.ejb3.timer-service.database-data-stores.KEY.refresh-interval: Interval between refreshing the current timer set against the underlying database. A low value means timers get picked up more quickly, but increase load on the database.
thorntail.ejb3.timer-service.default-data-store: The default data store used for persistent timers
thorntail.ejb3.timer-service.file-data-stores.KEY.path: The directory to store persistent timer information in
thorntail.ejb3.timer-service.file-data-stores.KEY.relative-to: The relative path that is used to resolve the timer data store location
thorntail.ejb3.timer-service.thread-pool-name: The name of the thread pool used to run timer service invocations

6.14.1. EJB Remote

Enables remote EJB and remote naming. If the messaging fraction is present, enables remote messaging as well.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>ejb-remote</artifactId>
</dependency>

6.15. Elytron

Elytron can generate the audit log to the same directory where the Thorntail application is executed. Include the following section in the project-defaults.yml file in your application:

thorntail:
  elytron:
    file-audit-logs:
      local-audit:
        path: audit.log

In some environments, for example cloud, you might have to relocate the audit file to a globally writable directory, for example:

thorntail:
  elytron:
    file-audit-logs:
      local-audit:
        path: /tmp/audit.log

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>elytron</artifactId>
</dependency>

Configuration

swarm.elytron.add-prefix-role-mappers.KEY.prefix: The prefix to add to each role.
swarm.elytron.add-suffix-role-mappers.KEY.suffix: The suffix to add to each role.
swarm.elytron.aggregate-http-server-mechanism-factories.KEY.available-mechanisms: The HTTP mechanisms available from this factory instance.
swarm.elytron.aggregate-http-server-mechanism-factories.KEY.http-server-mechanism-factories: The referenced http server factories to aggregate.
swarm.elytron.aggregate-principal-decoders.KEY.principal-decoders: The referenced principal decoders to aggregate.
swarm.elytron.aggregate-principal-transformers.KEY.principal-transformers: The referenced principal transformers to aggregate.
swarm.elytron.aggregate-providers.KEY.providers: The referenced Provider[] resources to aggregate.
swarm.elytron.aggregate-realms.KEY.authentication-realm: Reference to the security realm to use for authentication steps (obtaining or validating credentials).
swarm.elytron.aggregate-realms.KEY.authorization-realm: Reference to the security realm to use for loading the identity for authorization steps (loading of the identity).
swarm.elytron.aggregate-role-mappers.KEY.role-mappers: The referenced role mappers to aggregate.
swarm.elytron.aggregate-sasl-server-factories.KEY.available-mechanisms: The SASL mechanisms available from this factory after all filtering has been applied.
swarm.elytron.aggregate-sasl-server-factories.KEY.sasl-server-factories: The referenced sasl server factories to aggregate.
swarm.elytron.aggregate-security-event-listeners.KEY.security-event-listeners: The referenced security event listener resources to aggregate.
swarm.elytron.authentication-configurations.KEY.anonymous: Enables anonymous authentication.
swarm.elytron.authentication-configurations.KEY.attribute-extends: A previously defined authentication configuration to extend.
swarm.elytron.authentication-configurations.KEY.authentication-name: The authentication name to use.
swarm.elytron.authentication-configurations.KEY.authorization-name: The authorization name to use.
swarm.elytron.authentication-configurations.KEY.credential-reference: The reference to credential stored in CredentialStore under defined alias or clear text password.
swarm.elytron.authentication-configurations.KEY.forwarding-mode: The type of security identity forwarding to use. A mode of 'authentication' forwarding forwards the principal and credential. A mode of 'authorization' forwards the authorization id, allowing for a different authentication identity.
swarm.elytron.authentication-configurations.KEY.host: The host to use.
swarm.elytron.authentication-configurations.KEY.kerberos-security-factory: Reference to a kerberos security factory used to obtain a GSS kerberos credential
swarm.elytron.authentication-configurations.KEY.mechanism-properties: Configuration properties for the SASL authentication mechanism.
swarm.elytron.authentication-configurations.KEY.port: The port to use.
swarm.elytron.authentication-configurations.KEY.protocol: The protocol to use.
swarm.elytron.authentication-configurations.KEY.realm: The realm to use.
swarm.elytron.authentication-configurations.KEY.sasl-mechanism-selector: The SASL mechanism selector string.
swarm.elytron.authentication-configurations.KEY.security-domain: Reference to a security domain to obtain a forwarded identity.
swarm.elytron.authentication-contexts.KEY.attribute-extends: A previously defined authentication context to extend.
swarm.elytron.authentication-contexts.KEY.match-rules: The match-rules for this authentication context.
swarm.elytron.caching-realms.KEY.maximum-age: The time in milliseconds that an item can stay in the cache.
swarm.elytron.caching-realms.KEY.maximum-entries: The maximum number of entries to keep in the cache.
swarm.elytron.caching-realms.KEY.realm: A reference to a cacheable security realm.
swarm.elytron.chained-principal-transformers.KEY.principal-transformers: The referenced principal transformers to chain.
swarm.elytron.client-ssl-contexts.KEY.active-session-count: The count of current active sessions.
swarm.elytron.client-ssl-contexts.KEY.cipher-suite-filter: The filter to apply to specify the enabled cipher suites.
swarm.elytron.client-ssl-contexts.KEY.key-manager: Reference to the key manager to use within the SSLContext.
swarm.elytron.client-ssl-contexts.KEY.protocols: The enabled protocols.
swarm.elytron.client-ssl-contexts.KEY.provider-name: The name of the provider to use. If not specified, all providers from providers will be passed to the SSLContext.
swarm.elytron.client-ssl-contexts.KEY.providers: The name of the providers to obtain the Provider[] to use to load the SSLContext.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.application-buffer-size: The application buffer size as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.cipher-suite: The selected cipher suite as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.creation-time: The creation time as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.last-accessed-time: The last accessed time as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.local-certificates: The local certificates from the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.local-principal: The local principal as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.packet-buffer-size: The packet buffer size as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.peer-certificates: The peer certificates from the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.peer-host: The peer host as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.peer-port: The peer port as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.peer-principal: The peer principal as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.protocol: The protocol as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.ssl-sessions.KEY.valid: The validity of the session as reported by the SSLSession.
swarm.elytron.client-ssl-contexts.KEY.trust-manager: Reference to the trust manager to use within the SSLContext.
swarm.elytron.concatenating-principal-decoders.KEY.joiner: The string to use to join the results of the referenced principal decoders.
swarm.elytron.concatenating-principal-decoders.KEY.principal-decoders: The referenced principal decoders to concatenate.
swarm.elytron.configurable-http-server-mechanism-factories.KEY.available-mechanisms: The HTTP mechanisms available from this factory instance.
swarm.elytron.configurable-http-server-mechanism-factories.KEY.filters: Filtering to be applied to enable / disable mechanisms based on the name.
swarm.elytron.configurable-http-server-mechanism-factories.KEY.http-server-mechanism-factory: The http server factory to be wrapped.
swarm.elytron.configurable-http-server-mechanism-factories.KEY.properties: Custom properties to be passed in to the http server factory calls.
swarm.elytron.configurable-sasl-server-factories.KEY.available-mechanisms: The SASL mechanisms available from this factory after all filtering has been applied.
swarm.elytron.configurable-sasl-server-factories.KEY.filters: List of filters to be evaluated sequentially combining the results using 'or'.
swarm.elytron.configurable-sasl-server-factories.KEY.properties: Custom properties to be passed in to the sasl server factory calls.
swarm.elytron.configurable-sasl-server-factories.KEY.protocol: The protocol that should be passed into factory when creating the mechanism.
swarm.elytron.configurable-sasl-server-factories.KEY.sasl-server-factory: The sasl server factory to be wrapped.
swarm.elytron.configurable-sasl-server-factories.KEY.server-name: The server name that should be passed into factory when creating the mechanism.
swarm.elytron.constant-permission-mappers.KEY.permissions: The permissions to assign.
swarm.elytron.constant-principal-decoders.KEY.constant: The constant value the principal decoder will always return.
swarm.elytron.constant-principal-transformers.KEY.constant: The constant value this PrincipalTransformer will always return.
swarm.elytron.constant-realm-mappers.KEY.realm-name: The name of the constant realm to return.
swarm.elytron.constant-role-mappers.KEY.roles: The constant roles to be returned by this role mapper.
swarm.elytron.credential-stores.KEY.create: Specifies whether credential store should create storage when it doesn’t exist.
swarm.elytron.credential-stores.KEY.credential-reference: Credential reference to be used to create protection parameter.
swarm.elytron.credential-stores.KEY.implementation-properties: Map of credentials store implementation specific properties.
swarm.elytron.credential-stores.KEY.location: File name of credential store storage.
swarm.elytron.credential-stores.KEY.modifiable: Specifies whether credential store is modifiable.
swarm.elytron.credential-stores.KEY.other-providers: The name of the providers defined within the subsystem to obtain the Providers to search for the one that can create the required JCA objects within credential store. This is valid only for key-store based CredentialStore. If this is not specified then the global list of Providers is used instead.
swarm.elytron.credential-stores.KEY.provider-name: The name of the provider to use to instantiate the CredentialStoreSpi. If the provider is not specified then the first provider found that can create an instance of the specified 'type' will be used.
swarm.elytron.credential-stores.KEY.providers: The name of the providers defined within the subsystem to obtain the Providers to search for the one that can create the required CredentialStore type. If this is not specified then the global list of Providers is used instead.
swarm.elytron.credential-stores.KEY.relative-to: A reference to a previously defined path that the file name is relative to.
swarm.elytron.credential-stores.KEY.state: The state of the underlying service that represents this credential store at runtime.
swarm.elytron.credential-stores.KEY.type: The credential store type, e.g. KeyStoreCredentialStore.
swarm.elytron.custom-credential-security-factories.KEY.class-name: The class name of the implementation of the custom security factory.
swarm.elytron.custom-credential-security-factories.KEY.configuration: The optional key/value configuration for the custom security factory.
swarm.elytron.custom-credential-security-factories.KEY.module: The module to use to load the custom security factory.
swarm.elytron.custom-modifiable-realms.KEY.class-name: The class name of the implementation of the custom realm.
swarm.elytron.custom-modifiable-realms.KEY.configuration: The optional key/value configuration for the custom realm.
swarm.elytron.custom-modifiable-realms.KEY.module: The module to use to load the custom realm.
swarm.elytron.custom-permission-mappers.KEY.class-name: Fully qualified class name of the permission mapper
swarm.elytron.custom-permission-mappers.KEY.configuration: The optional kay/value configuration for the permission mapper
swarm.elytron.custom-permission-mappers.KEY.module: Name of the module to use to load the permission mapper
swarm.elytron.custom-principal-decoders.KEY.class-name: Fully qualified class name of the principal decoder
swarm.elytron.custom-principal-decoders.KEY.configuration: The optional kay/value configuration for the principal decoder
swarm.elytron.custom-principal-decoders.KEY.module: Name of the module to use to load the principal decoder
swarm.elytron.custom-principal-transformers.KEY.class-name: The class name of the implementation of the custom principal transformer.
swarm.elytron.custom-principal-transformers.KEY.configuration: The optional key/value configuration for the custom principal transformer.
swarm.elytron.custom-principal-transformers.KEY.module: The module to use to load the custom principal transformer.
swarm.elytron.custom-realm-mappers.KEY.class-name: Fully qualified class name of the RealmMapper
swarm.elytron.custom-realm-mappers.KEY.configuration: The optional kay/value configuration for the RealmMapper
swarm.elytron.custom-realm-mappers.KEY.module: Name of the module to use to load the RealmMapper
swarm.elytron.custom-realms.KEY.class-name: The class name of the implementation of the custom realm.
swarm.elytron.custom-realms.KEY.configuration: The optional key/value configuration for the custom realm.
swarm.elytron.custom-realms.KEY.module: The module to use to load the custom realm.
swarm.elytron.custom-role-decoders.KEY.class-name: Fully qualified class name of the RoleDecoder
swarm.elytron.custom-role-decoders.KEY.configuration: The optional kay/value configuration for the RoleDecoder
swarm.elytron.custom-role-decoders.KEY.module: Name of the module to use to load the RoleDecoder
swarm.elytron.custom-role-mappers.KEY.class-name: Fully qualified class name of the RoleMapper
swarm.elytron.custom-role-mappers.KEY.configuration: The optional key/value configuration for the RoleMapper
swarm.elytron.custom-role-mappers.KEY.module: Name of the module to use to load the RoleMapper
swarm.elytron.default-authentication-context: The default authentication context to be associated with all deployments.
swarm.elytron.dir-contexts.KEY.authentication-context: The authentication context to obtain login credentials to connect to the LDAP server. Can be omitted if authentication-level is "none" (anonymous).
swarm.elytron.dir-contexts.KEY.authentication-level: The authentication level (security level/authentication mechanism) to use. Corresponds to SECURITY_AUTHENTICATION ("java.naming.security.authentication") environment property. Allowed values: "none", "simple", sasl_mech, where sasl_mech is a space-separated list of SASL mechanism names.
swarm.elytron.dir-contexts.KEY.connection-timeout: The timeout for connecting to the LDAP server in milliseconds.
swarm.elytron.dir-contexts.KEY.credential-reference: The credential reference to authenticate and connect to the LDAP server. Can be omitted if authentication-level is "none" (anonymous).
swarm.elytron.dir-contexts.KEY.enable-connection-pooling: Indicates if connection pooling is enabled.
swarm.elytron.dir-contexts.KEY.module: Name of module that will be used as class loading base.
swarm.elytron.dir-contexts.KEY.principal: The principal to authenticate and connect to the LDAP server. Can be omitted if authentication-level is "none" (anonymous).
swarm.elytron.dir-contexts.KEY.properties: The additional connection properties for the DirContext.
swarm.elytron.dir-contexts.KEY.read-timeout: The read timeout for an LDAP operation in milliseconds.
swarm.elytron.dir-contexts.KEY.referral-mode: If referrals should be followed.
swarm.elytron.dir-contexts.KEY.ssl-context: The name of ssl-context used to secure connection to the LDAP server.
swarm.elytron.dir-contexts.KEY.url: The connection url.
swarm.elytron.disallowed-providers: A list of providers that are not allowed, and will be removed from the providers list.
swarm.elytron.file-audit-logs.KEY.attribute-synchronized: Whether every event should be immediately synchronised to disk.
swarm.elytron.file-audit-logs.KEY.format: The format to use to record the audit event.
swarm.elytron.file-audit-logs.KEY.path: Path of the file to be written.
swarm.elytron.file-audit-logs.KEY.relative-to: The relative path to the audit log.
swarm.elytron.filesystem-realms.KEY.encoded: Whether the identity names should be stored encoded (Base32) in file names.
swarm.elytron.filesystem-realms.KEY.levels: The number of levels of directory hashing to apply.
swarm.elytron.filesystem-realms.KEY.path: The path to the file containing the realm.
swarm.elytron.filesystem-realms.KEY.relative-to: The pre-defined path the path is relative to.
swarm.elytron.filtering-key-stores.KEY.alias-filter: A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2
swarm.elytron.filtering-key-stores.KEY.key-store: Name of filtered KeyStore.
swarm.elytron.filtering-key-stores.KEY.state: The state of the underlying service that represents this KeyStore at runtime, if it is anything other than UP runtime operations will not be available.
swarm.elytron.final-providers: Reference to the Providers that should be registered after all existing Providers.
swarm.elytron.http-authentication-factories.KEY.available-mechanisms: The HTTP mechanisms available from this configuration after all filtering has been applied.
swarm.elytron.http-authentication-factories.KEY.http-server-mechanism-factory: The HttpServerAuthenticationMechanismFactory to associate with this resource
swarm.elytron.http-authentication-factories.KEY.mechanism-configurations: Mechanism specific configuration
swarm.elytron.http-authentication-factories.KEY.security-domain: The SecurityDomain to associate with this resource
swarm.elytron.identity-realms.KEY.attribute-name: The name of the attribute associated with this identity.
swarm.elytron.identity-realms.KEY.attribute-values: The values associated with the identities attribute.
swarm.elytron.identity-realms.KEY.identity: The identity available from the security realm.
swarm.elytron.initial-providers: Reference to the Providers that should be registered ahead of all existing Providers.
swarm.elytron.jdbc-realms.KEY.principal-query: The authentication query used to authenticate users based on specific key types.
swarm.elytron.kerberos-security-factories.KEY.debug: Should the JAAS step of obtaining the credential have debug logging enabled.
swarm.elytron.kerberos-security-factories.KEY.mechanism-names: The mechanism names the credential should be usable with. Names will be converted to OIDs and used together with OIDs from mechanism-oids attribute.
swarm.elytron.kerberos-security-factories.KEY.mechanism-oids: The mechanism OIDs the credential should be usable with. Will be used together with OIDs derived from names from mechanism-names attribute.
swarm.elytron.kerberos-security-factories.KEY.minimum-remaining-lifetime: How much lifetime (in seconds) should a cached credential have remaining before it is recreated.
swarm.elytron.kerberos-security-factories.KEY.obtain-kerberos-ticket: Should the KerberosTicket also be obtained and associated with the credential. This is required to be true where credentials are delegated to the server.
swarm.elytron.kerberos-security-factories.KEY.options: The Krb5LoginModule additional options.
swarm.elytron.kerberos-security-factories.KEY.path: The path of the KeyTab to load to obtain the credential.
swarm.elytron.kerberos-security-factories.KEY.principal: The principal represented by the KeyTab
swarm.elytron.kerberos-security-factories.KEY.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
swarm.elytron.kerberos-security-factories.KEY.request-lifetime: How much lifetime (in seconds) should be requested for newly created credentials.
swarm.elytron.kerberos-security-factories.KEY.required: Is the keytab file with adequate principal required to exist at the time the service starts?
swarm.elytron.kerberos-security-factories.KEY.server: If this for use server side or client side?
swarm.elytron.kerberos-security-factories.KEY.wrap-gss-credential: Should generated GSS credentials be wrapped to prevent improper disposal or not?
swarm.elytron.key-managers.KEY.algorithm: The name of the algorithm to use to create the underlying KeyManagerFactory.
swarm.elytron.key-managers.KEY.alias-filter: A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2
swarm.elytron.key-managers.KEY.credential-reference: The credential reference to decrypt KeyStore item. (Not a password of the KeyStore.)
swarm.elytron.key-managers.KEY.key-store: Reference to the KeyStore to use to initialise the underlying KeyManagerFactory.
swarm.elytron.key-managers.KEY.provider-name: The name of the provider to use to create the underlying KeyManagerFactory.
swarm.elytron.key-managers.KEY.providers: Reference to obtain the Provider[] to use when creating the underlying KeyManagerFactory.
swarm.elytron.key-store-realms.KEY.key-store: Reference to the KeyStore that should be used to back this security realm.
swarm.elytron.key-stores.KEY.alias-filter: A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2
swarm.elytron.key-stores.KEY.attribute-synchronized: The time this KeyStore was last loaded or saved. Note: Some providers may continue to apply updates after the KeyStore was loaded within the application server.
swarm.elytron.key-stores.KEY.credential-reference: The reference to credential stored in CredentialStore under defined alias or clear text password.
swarm.elytron.key-stores.KEY.loaded-provider: Information about the provider that was used for this KeyStore.
swarm.elytron.key-stores.KEY.modified: Indicates if the in-memory representation of the KeyStore has been changed since it was last loaded or stored. Note: For some providers updates may be immediate without further load or store calls.
swarm.elytron.key-stores.KEY.path: The path to the KeyStore file.
swarm.elytron.key-stores.KEY.provider-name: The name of the provider to use to load the KeyStore, disables searching for the first Provider that can create a KeyStore of the specified type.
swarm.elytron.key-stores.KEY.providers: A reference to the providers that should be used to obtain the list of Provider instances to search, if not specified the global list of providers will be used instead.
swarm.elytron.key-stores.KEY.relative-to: The base path this store is relative to.
swarm.elytron.key-stores.KEY.required: Is the file required to exist at the time the KeyStore service starts?
swarm.elytron.key-stores.KEY.size: The number of entries in the KeyStore.
swarm.elytron.key-stores.KEY.state: The state of the underlying service that represents this KeyStore at runtime, if it is anything other than UP runtime operations will not be available.
swarm.elytron.key-stores.KEY.type: The type of the KeyStore, used when creating the new KeyStore instance.
swarm.elytron.ldap-key-stores.KEY.alias-attribute: The name of LDAP attribute, where will be item alias stored.
swarm.elytron.ldap-key-stores.KEY.certificate-attribute: The name of LDAP attribute, where will be certificate stored.
swarm.elytron.ldap-key-stores.KEY.certificate-chain-attribute: The name of LDAP attribute, where will be certificate chain stored.
swarm.elytron.ldap-key-stores.KEY.certificate-chain-encoding: The encoding of the certificate chain.
swarm.elytron.ldap-key-stores.KEY.certificate-type: The type of the Certificate.
swarm.elytron.ldap-key-stores.KEY.dir-context: The name of DirContext, which will be used to communication with LDAP server.
swarm.elytron.ldap-key-stores.KEY.filter-alias: The LDAP filter for obtaining an item of the KeyStore by alias. If this is not specified then the default value will be (alias_attribute={0}). The string '{0}' will be replaced by the searched alias and the 'alias_attribute' value will be the value of the attribute 'alias-attribute'.
swarm.elytron.ldap-key-stores.KEY.filter-certificate: The LDAP filter for obtaining an item of the KeyStore by certificate. If this is not specified then the default value will be (certificate_attribute={0}). The string '{0}' will be replaced by searched encoded certificate and the 'certificate_attribute' will be the value of the attribute 'certificate-attribute'.
swarm.elytron.ldap-key-stores.KEY.filter-iterate: The LDAP filter for iterating over all items of the KeyStore. If this is not specified then the default value will be (alias_attribute=*). The 'alias_attribute' will be the value of the attribute 'alias-attribute'.
swarm.elytron.ldap-key-stores.KEY.key-attribute: The name of LDAP attribute, where will be key stored.
swarm.elytron.ldap-key-stores.KEY.key-type: The type of KeyStore, in which will be key serialized to LDAP attribute.
swarm.elytron.ldap-key-stores.KEY.new-item-template: Configuration for item creation. Define how will look LDAP entry of newly created keystore item.
swarm.elytron.ldap-key-stores.KEY.search-path: The path in LDAP, where will be KeyStore items searched.
swarm.elytron.ldap-key-stores.KEY.search-recursive: If the LDAP search should be recursive.
swarm.elytron.ldap-key-stores.KEY.search-time-limit: The time limit for obtaining keystore items from LDAP.
swarm.elytron.ldap-key-stores.KEY.size: The size of LDAP KeyStore in amount of items/aliases.
swarm.elytron.ldap-key-stores.KEY.state: The state of the underlying service that represents this KeyStore at runtime, if it is anything other than UP runtime operations will not be available.
swarm.elytron.ldap-realms.KEY.allow-blank-password: Does this realm support blank password direct verification? Blank password attempt will be rejected otherwise.
swarm.elytron.ldap-realms.KEY.dir-context: The configuration to connect to a LDAP server.
swarm.elytron.ldap-realms.KEY.direct-verification: Does this realm support verification of credentials by directly connecting to LDAP as the account being authenticated?
swarm.elytron.ldap-realms.KEY.identity-mapping: The configuration options that define how principals are mapped to their corresponding entries in the underlying LDAP server.
swarm.elytron.logical-permission-mappers.KEY.left: Reference to the permission mapper to use to the left of the operation.
swarm.elytron.logical-permission-mappers.KEY.logical-operation: The logical operation to use to combine the permission mappers.
swarm.elytron.logical-permission-mappers.KEY.right: Reference to the permission mapper to use to the right of the operation.
swarm.elytron.logical-role-mappers.KEY.left: Reference to a role mapper to be used on the left side of the operation.
swarm.elytron.logical-role-mappers.KEY.logical-operation: The logical operation to be performed on the role mapper mappings.
swarm.elytron.logical-role-mappers.KEY.right: Reference to a role mapper to be used on the right side of the operation.
swarm.elytron.mapped-regex-realm-mappers.KEY.delegate-realm-mapper: The RealmMapper to delegate to if the pattern does not match. If no delegate is specified then the default realm on the domain will be used instead. If the username does not match the pattern and a delegate realm-mapper is present, the result of delegate-realm-mapper is mapped via the realm-map.
swarm.elytron.mapped-regex-realm-mappers.KEY.pattern: The regular expression which must contain at least one capture group to extract the realm from the name. If the regular expression matches more than one capture group, the first capture group is used.
swarm.elytron.mapped-regex-realm-mappers.KEY.realm-map: Mapping of realm name extracted using the regular expression to a defined realm name. If the value for the mapping is not in the map or the realm whose name is the result of the mapping does not exist in the given security domain, the default realm is used.
swarm.elytron.mechanism-provider-filtering-sasl-server-factories.KEY.available-mechanisms: The SASL mechanisms available from this factory after all filtering has been applied.
swarm.elytron.mechanism-provider-filtering-sasl-server-factories.KEY.enabling: When set to 'true' no provider loaded mechanisms are enabled unless matched by one of the filters, setting to 'false' has the inverse effect.
swarm.elytron.mechanism-provider-filtering-sasl-server-factories.KEY.filters: The filters to apply when comparing the mechanisms from the providers, a filter matches when all of the specified values match the mechanism / provider pair.
swarm.elytron.mechanism-provider-filtering-sasl-server-factories.KEY.sasl-server-factory: Reference to a sasl server factory to be wrapped by this definition.
swarm.elytron.periodic-rotating-file-audit-logs.KEY.attribute-synchronized: Whether every event should be immediately synchronised to disk.
swarm.elytron.periodic-rotating-file-audit-logs.KEY.format: The format to use to record the audit event.
swarm.elytron.periodic-rotating-file-audit-logs.KEY.path: Path of the file to be written.
swarm.elytron.periodic-rotating-file-audit-logs.KEY.relative-to: The relative path to the audit log.
swarm.elytron.periodic-rotating-file-audit-logs.KEY.suffix: The suffix string in a format which can be understood by java.time.format.DateTimeFormatter. The period of the rotation is automatically calculated based on the suffix.
swarm.elytron.policies.KEY.custom-policy: A custom policy provider definition.
swarm.elytron.policies.KEY.jacc-policy: A policy provider definition that sets up JACC and related services.
swarm.elytron.properties-realms.KEY.attribute-synchronized: The time the properties files that back this realm were last loaded.
swarm.elytron.properties-realms.KEY.groups-attribute: The name of the attribute in the returned AuthorizationIdentity that should contain the group membership information for the identity.
swarm.elytron.properties-realms.KEY.groups-properties: The properties file containing the users and their groups.
swarm.elytron.properties-realms.KEY.users-properties: The properties file containing the users and their passwords.
swarm.elytron.provider-http-server-mechanism-factories.KEY.available-mechanisms: The HTTP mechanisms available from this factory instance.
swarm.elytron.provider-http-server-mechanism-factories.KEY.providers: The providers to use to locate the factories, if not specified the globally registered list of Providers will be used.
swarm.elytron.provider-loaders.KEY.argument: An argument to be passed into the constructor as the Provider is instantiated.
swarm.elytron.provider-loaders.KEY.class-names: The fully qualified class names of the providers to load, these are loaded after the service-loader discovered providers and duplicates will be skipped.
swarm.elytron.provider-loaders.KEY.configuration: The key/value configuration to be passed to the Provider to initialise it.
swarm.elytron.provider-loaders.KEY.loaded-providers: The list of providers loaded by this provider loader.
swarm.elytron.provider-loaders.KEY.module: The name of the module to load the provider from.
swarm.elytron.provider-loaders.KEY.path: The path of the file to use to initialise the providers.
swarm.elytron.provider-loaders.KEY.relative-to: The base path of the configuration file.
swarm.elytron.provider-sasl-server-factories.KEY.available-mechanisms: The SASL mechanisms available from this factory after all filtering has been applied.
swarm.elytron.provider-sasl-server-factories.KEY.providers: The providers to use to locate the factories, if not specified the globally registered list of Providers will be used.
swarm.elytron.regex-principal-transformers.KEY.pattern: The regular expression to use to locate the portion of the name to be replaced.
swarm.elytron.regex-principal-transformers.KEY.replace-all: Should all occurrences of the pattern matched be replaced or only the first occurrence.
swarm.elytron.regex-principal-transformers.KEY.replacement: The value to be used as the replacement.
swarm.elytron.regex-validating-principal-transformers.KEY.match: If set to true, the name must match the given pattern to make validation successful. If set to false, the name must not match the given pattern to make validation successful.
swarm.elytron.regex-validating-principal-transformers.KEY.pattern: The regular expression to use for the principal transformer.
swarm.elytron.sasl-authentication-factories.KEY.available-mechanisms: The SASL mechanisms available from this configuration after all filtering has been applied.
swarm.elytron.sasl-authentication-factories.KEY.mechanism-configurations: Mechanism specific configuration
swarm.elytron.sasl-authentication-factories.KEY.sasl-server-factory: The SaslServerFactory to associate with this resource
swarm.elytron.sasl-authentication-factories.KEY.security-domain: The SecurityDomain to associate with this resource
swarm.elytron.security-domains.KEY.default-realm: The default realm contained by this security domain.
swarm.elytron.security-domains.KEY.outflow-anonymous: When outflowing to a security domain if outflow is not possible should the anonymous identity be used? Outflowing anonymous has the effect of clearing any identity already established for that domain.
swarm.elytron.security-domains.KEY.outflow-security-domains: The list of security domains that the security identity from this domain should automatically outflow to.
swarm.elytron.security-domains.KEY.permission-mapper: A reference to a PermissionMapper to be used by this domain.
swarm.elytron.security-domains.KEY.post-realm-principal-transformer: A reference to a principal transformer to be applied after the realm has operated on the supplied identity name.
swarm.elytron.security-domains.KEY.pre-realm-principal-transformer: A reference to a principal transformer to be applied before the realm is selected.
swarm.elytron.security-domains.KEY.principal-decoder: A reference to a PrincipalDecoder to be used by this domain.
swarm.elytron.security-domains.KEY.realm-mapper: Reference to the RealmMapper to be used by this domain.
swarm.elytron.security-domains.KEY.realms: The list of realms contained by this security domain.
swarm.elytron.security-domains.KEY.role-mapper: Reference to the RoleMapper to be used by this domain.
swarm.elytron.security-domains.KEY.security-event-listener: Reference to a listener for security events.
swarm.elytron.security-domains.KEY.trusted-security-domains: The list of security domains that are trusted by this security domain.
swarm.elytron.security-properties: Security properties to be set.
swarm.elytron.server-ssl-contexts.KEY.active-session-count: The count of current active sessions.
swarm.elytron.server-ssl-contexts.KEY.authentication-optional: Rejecting of the client certificate by the security domain will not prevent the connection. Allows a fall through to use other authentication mechanisms (like form login) when the client certificate is rejected by security domain. Has an effect only when the security domain is set.
swarm.elytron.server-ssl-contexts.KEY.cipher-suite-filter: The filter to apply to specify the enabled cipher suites.
swarm.elytron.server-ssl-contexts.KEY.final-principal-transformer: A final principal transformer to apply for this mechanism realm.
swarm.elytron.server-ssl-contexts.KEY.key-manager: Reference to the key manager to use within the SSLContext.
swarm.elytron.server-ssl-contexts.KEY.maximum-session-cache-size: The maximum number of SSL sessions in the cache. The default value -1 means use the JVM default value. Value zero means there is no limit.
swarm.elytron.server-ssl-contexts.KEY.need-client-auth: To require a client certificate on SSL handshake. Connection without trusted client certificate (see trust-manager) will be rejected.
swarm.elytron.server-ssl-contexts.KEY.post-realm-principal-transformer: A principal transformer to apply after the realm is selected.
swarm.elytron.server-ssl-contexts.KEY.pre-realm-principal-transformer: A principal transformer to apply before the realm is selected.
swarm.elytron.server-ssl-contexts.KEY.protocols: The enabled protocols.
swarm.elytron.server-ssl-contexts.KEY.provider-name: The name of the provider to use. If not specified, all providers from providers will be passed to the SSLContext.
swarm.elytron.server-ssl-contexts.KEY.providers: The name of the providers to obtain the Provider[] to use to load the SSLContext.
swarm.elytron.server-ssl-contexts.KEY.realm-mapper: The realm mapper to be used for SSL authentication.
swarm.elytron.server-ssl-contexts.KEY.security-domain: The security domain to use for authentication during SSL session establishment.
swarm.elytron.server-ssl-contexts.KEY.session-timeout: The timeout for SSL sessions, in seconds. The default value -1 means use the JVM default value. Value zero means there is no limit.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.application-buffer-size: The application buffer size as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.cipher-suite: The selected cipher suite as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.creation-time: The creation time as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.last-accessed-time: The last accessed time as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.local-certificates: The local certificates from the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.local-principal: The local principal as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.packet-buffer-size: The packet buffer size as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.peer-certificates: The peer certificates from the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.peer-host: The peer host as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.peer-port: The peer port as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.peer-principal: The peer principal as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.protocol: The protocol as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.ssl-sessions.KEY.valid: The validity of the session as reported by the SSLSession.
swarm.elytron.server-ssl-contexts.KEY.trust-manager: Reference to the trust manager to use within the SSLContext.
swarm.elytron.server-ssl-contexts.KEY.use-cipher-suites-order: To honor local cipher suites preference.
swarm.elytron.server-ssl-contexts.KEY.want-client-auth: To request (but not to require) a client certificate on SSL handshake. If a security domain is referenced and supports X509 evidence, this will be set to true automatically. Ignored when need-client-auth is set.
swarm.elytron.server-ssl-contexts.KEY.wrap: Should the SSLEngine, SSLSocket, and SSLServerSocket instances returned be wrapped to protect against further modification.
swarm.elytron.service-loader-http-server-mechanism-factories.KEY.available-mechanisms: The HTTP mechanisms available from this factory instance.
swarm.elytron.service-loader-http-server-mechanism-factories.KEY.module: The module to use to obtain the classloader to load the factories, if not specified the classloader to load the resource will be used instead.
swarm.elytron.service-loader-sasl-server-factories.KEY.available-mechanisms: The SASL mechanisms available from this factory after all filtering has been applied.
swarm.elytron.service-loader-sasl-server-factories.KEY.module: The module to use to obtain the classloader to load the factories, if not specified the classloader to load the resource will be used instead.
swarm.elytron.simple-permission-mappers.KEY.mapping-mode: The mapping mode that should be used in the event of multiple matches.
swarm.elytron.simple-permission-mappers.KEY.permission-mappings: The defined permission mappings.
swarm.elytron.simple-regex-realm-mappers.KEY.delegate-realm-mapper: The RealmMapper to delegate to if there is no match using the pattern.
swarm.elytron.simple-regex-realm-mappers.KEY.pattern: The regular expression which must contain at least one capture group to extract the realm from the name. If the regular expression matches more than one capture group, the first capture group is used.
swarm.elytron.simple-role-decoders.KEY.attribute: The name of the attribute from the identity to map directly to roles.
swarm.elytron.size-rotating-file-audit-logs.KEY.attribute-synchronized: Whether every event should be immediately synchronised to disk.
swarm.elytron.size-rotating-file-audit-logs.KEY.format: The format to use to record the audit event.
swarm.elytron.size-rotating-file-audit-logs.KEY.max-backup-index: The maximum number of files to backup when rotating.
swarm.elytron.size-rotating-file-audit-logs.KEY.path: Path of the file to be written.
swarm.elytron.size-rotating-file-audit-logs.KEY.relative-to: The relative path to the audit log.
swarm.elytron.size-rotating-file-audit-logs.KEY.rotate-on-boot: Whether the file should be rotated before the a new file is set.
swarm.elytron.size-rotating-file-audit-logs.KEY.rotate-size: The log file size the file should rotate at.
swarm.elytron.size-rotating-file-audit-logs.KEY.suffix: Format of date used as suffix of log file names in java.time.format.DateTimeFormatter. The suffix does not play a role in determining when the file should be rotated.
swarm.elytron.syslog-audit-logs.KEY.format: The format to use to record the audit event.
swarm.elytron.syslog-audit-logs.KEY.host-name: The host name to embed withing all events sent to the remote syslog server.
swarm.elytron.syslog-audit-logs.KEY.port: The listening port on the syslog server.
swarm.elytron.syslog-audit-logs.KEY.server-address: The server address of the syslog server the events should be sent to.
swarm.elytron.syslog-audit-logs.KEY.ssl-context: The SSLContext to use to connect to the syslog server when SSL_TCP transport is used.
swarm.elytron.syslog-audit-logs.KEY.transport: The transport to use to connect to the syslog server.
swarm.elytron.token-realms.KEY.jwt: A token validator to be used in conjunction with a token-based realm that handles security tokens based on the JWT/JWS standard.
swarm.elytron.token-realms.KEY.oauth2-introspection: A token validator to be used in conjunction with a token-based realm that handles OAuth2 Access Tokens and validates them using an endpoint compliant with OAuth2 Token Introspection specification(RFC-7662).
swarm.elytron.token-realms.KEY.principal-claim: The name of the claim that should be used to obtain the principal’s name.
swarm.elytron.trust-managers.KEY.algorithm: The name of the algorithm to use to create the underlying TrustManagerFactory.
swarm.elytron.trust-managers.KEY.alias-filter: A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2
swarm.elytron.trust-managers.KEY.certificate-revocation-list: Enables certificate revocation list checks to a trust manager.
swarm.elytron.trust-managers.KEY.key-store: Reference to the KeyStore to use to initialise the underlying TrustManagerFactory.
swarm.elytron.trust-managers.KEY.provider-name: The name of the provider to use to create the underlying TrustManagerFactory.
swarm.elytron.trust-managers.KEY.providers: Reference to obtain the Provider[] to use when creating the underlying TrustManagerFactory.
swarm.elytron.x500-attribute-principal-decoders.KEY.attribute-name: The name of the X.500 attribute to map (can be defined using OID instead)
swarm.elytron.x500-attribute-principal-decoders.KEY.convert: When set to 'true', if the Principal is not already an X500Principal conversion will be attempted
swarm.elytron.x500-attribute-principal-decoders.KEY.joiner: The joining string
swarm.elytron.x500-attribute-principal-decoders.KEY.maximum-segments: The maximum number of occurrences of the attribute to map
swarm.elytron.x500-attribute-principal-decoders.KEY.oid: The OID of the X.500 attribute to map (can be defined using attribute name instead)
swarm.elytron.x500-attribute-principal-decoders.KEY.required-attributes: The attributes names of the attributes that must be present in the principal
swarm.elytron.x500-attribute-principal-decoders.KEY.required-oids: The OIDs of the attributes that must be present in the principal
swarm.elytron.x500-attribute-principal-decoders.KEY.reverse: When set to 'true', the attribute values will be processed and returned in reverse order
swarm.elytron.x500-attribute-principal-decoders.KEY.start-segment: The 0-based starting occurrence of the attribute to map

6.16. Fluentd

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>fluentd</artifactId>
</dependency>

Configuration

swarm.fluentd.hostname: Host name of the fluentd server
swarm.fluentd.level: Logging level
swarm.fluentd.port: Port of the fluentd server
swarm.fluentd.tag: Logging tag

6.17. Flyway

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>flyway</artifactId>
</dependency>

Configuration

thorntail.flyway.jdbc-password: JDBC connection password
thorntail.flyway.jdbc-url: JDBC connection URL
thorntail.flyway.jdbc-user: JDBC connection user name

6.18. Full

Provides a collection of fractions equivalent to the _Full Platform:

Bean Validation
Batch
CDI
Datasources
EJB
EJB-Remote
JCA
JMX
JAX-RS
- JSON-P
- JAXB
- Multipart
- Validator
JPA
JSF
Mail
Messaging
Resource Adapters
Transactions
Undertow (Servlets)
WebServices

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>full</artifactId>
</dependency>

6.19. Hibernate Search

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>hibernate-search</artifactId>
</dependency>

6.20. Hibernate Validator

Provides support and integration for applications using Hibernate Validator.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>hibernate-validator</artifactId>
</dependency>

6.21. Hystrix

Warning

This fraction is deprecated.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>hystrix</artifactId>
</dependency>

Configuration

thorntail.hystrix.collapser.default.maxRequestsInBatch: The maximum number of requests allowed in a batch before this triggers a batch execution
thorntail.hystrix.collapser.default.requestCache.enabled: Indicates whether request caching is enabled for HystrixCollapser.execute() and HystrixCollapser.queue() invocations
thorntail.hystrix.collapser.default.timerDelayInMilliseconds: The number of milliseconds after the creation of the batch that its execution is triggered
thorntail.hystrix.command.default.circuitBreaker.enabled: Determines whether a circuit breaker will be used to track health and to short-circuit requests if it trips
thorntail.hystrix.command.default.circuitBreaker.errorThresholdPercentage: The error percentage at or above which the circuit should trip open and start short-circuiting requests to fallback logic
thorntail.hystrix.command.default.circuitBreaker.forceClosed: If true, forces the circuit breaker into a closed state in which it will allow requests regardless of the error percentage
thorntail.hystrix.command.default.circuitBreaker.forceOpen: If true, forces the circuit breaker into an open (tripped) state in which it will reject all requests
thorntail.hystrix.command.default.circuitBreaker.requestVolumeThreshold: The minimum number of requests in a rolling window that will trip the circuit
thorntail.hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds: The amount of time, after tripping the circuit, to reject requests before allowing attempts again to determine if the circuit should again be closed
thorntail.hystrix.command.default.execution.isolation.semaphore.maxConcurrentRequests: The maximum number of requests allowed to a HystrixCommand.run() method when you are using ExecutionIsolationStrategy.SEMAPHORE
thorntail.hystrix.command.default.execution.isolation.strategy: Isolation strategy (THREAD or SEMAPHORE)
thorntail.hystrix.command.default.execution.isolation.thread.interruptOnCancel: Indicates whether the HystrixCommand.run() execution should be interrupted when a cancellation occurs
thorntail.hystrix.command.default.execution.isolation.thread.interruptOnTimeout: Indicates whether the HystrixCommand.run() execution should be interrupted when a timeout occurs
thorntail.hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: The time in milliseconds after which the caller will observe a timeout and walk away from the command execution
thorntail.hystrix.command.default.execution.timeout.enabled: Indicates whether the HystrixCommand.run() execution should have a timeout
thorntail.hystrix.command.default.fallback.enabled: Determines whether a call to HystrixCommand.getFallback() will be attempted when failure or rejection occurs
thorntail.hystrix.command.default.fallback.isolation.semaphore.maxConcurrentRequests: The maximum number of requests allowed to a HystrixCommand.getFallback() method when you are using ExecutionIsolationStrategy.SEMAPHORE
thorntail.hystrix.command.default.metrics.healthSnapshot.intervalInMilliseconds: The time to wait, in milliseconds, between allowing health snapshots to be taken that calculate success and error percentages and affect circuit breaker status
thorntail.hystrix.command.default.metrics.rollingPercentile.bucketSize: The maximum number of execution times that are kept per bucket
thorntail.hystrix.command.default.metrics.rollingPercentile.enabled: Indicates whether execution latencies should be tracked and calculated as percentiles
thorntail.hystrix.command.default.metrics.rollingPercentile.numBuckets: The number of buckets the rollingPercentile window will be divided into
thorntail.hystrix.command.default.metrics.rollingPercentile.timeInMilliseconds: The duration of the rolling window in which execution times are kept to allow for percentile calculations, in milliseconds
thorntail.hystrix.command.default.metrics.rollingStats.numBuckets: The number of buckets the rolling statistical window is divided into
thorntail.hystrix.command.default.metrics.rollingStats.timeInMilliseconds: The duration of the statistical rolling window, in milliseconds. This is how long Hystrix keeps metrics for the circuit breaker to use and for publishing
thorntail.hystrix.command.default.requestCache.enabled: Indicates whether HystrixCommand.getCacheKey() should be used with HystrixRequestCache to provide de-duplication functionality via request-scoped caching
thorntail.hystrix.command.default.requestLog.enabled: Indicates whether HystrixCommand execution and events should be logged to HystrixRequestLog
thorntail.hystrix.stream.path: Context path for the stream
thorntail.hystrix.threadpool.default.allowMaximumSizeToDivergeFromCoreSize: Allows the configuration for maximumSize to take effect
thorntail.hystrix.threadpool.default.coreSize: The core thread-pool size
thorntail.hystrix.threadpool.default.keepAliveTimeMinutes: The keep-alive time, in minutes
thorntail.hystrix.threadpool.default.maxQueueSize: The maximum queue size of the BlockingQueue implementation
thorntail.hystrix.threadpool.default.maximumSize: The maximum thread-pool size
thorntail.hystrix.threadpool.default.metrics.rollingPercentile.numBuckets: The number of buckets the rolling statistical window is divided into
thorntail.hystrix.threadpool.default.metrics.rollingStats.timeInMilliseconds: The duration of the statistical rolling window, in milliseconds
thorntail.hystrix.threadpool.default.queueSizeRejectionThreshold: The queue size rejection threshold - an artificial maximum queue size at which rejections will occur even if maxQueueSize has not been reached

6.22. Infinispan

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>infinispan</artifactId>
</dependency>

Configuration

swarm.infinispan.cache-containers.KEY.aliases: The list of aliases for this cache container
swarm.infinispan.cache-containers.KEY.async-operations-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.async-operations-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.async-operations-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.infinispan.cache-containers.KEY.async-operations-thread-pool.queue-length: The queue length.
swarm.infinispan.cache-containers.KEY.cache-manager-status: The status of the cache manager component. May return null if the cache manager is not started.
swarm.infinispan.cache-containers.KEY.cluster-name: The name of the cluster this node belongs to. May return null if the cache manager is not started.
swarm.infinispan.cache-containers.KEY.coordinator-address: The logical address of the cluster’s coordinator. May return null if the cache manager is not started.
swarm.infinispan.cache-containers.KEY.default-cache: The default infinispan cache
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.activations: The number of cache node activations (bringing a node into memory from a cache store) . May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.async-marshalling: If enabled, this will cause marshalling of entries to be performed asynchronously.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.average-read-time: Average time (in ms) for cache reads. Includes hits and misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.average-replication-time: The average time taken to replicate data around the cluster. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.average-write-time: Average time (in ms) for cache writes. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backup-for-component.remote-cache: The name of the remote cache for which this cache acts as a backup.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backup-for-component.remote-site: The site of the remote cache for which this cache acts as a backup.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backups-component.backups.KEY.after-failures: Indicates the number of failures after which this backup site should go offline.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backups-component.backups.KEY.enabled: Indicates whether or not this backup site is enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backups-component.backups.KEY.failure-policy: The policy to follow when connectivity to the backup site fails.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backups-component.backups.KEY.min-wait: Indicates the minimum time (in milliseconds) to wait after the max number of failures is reached, after which this backup site should go offline.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backups-component.backups.KEY.strategy: The backup strategy for this cache
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.backups-component.backups.KEY.timeout: The timeout for replicating to the backup site.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.binary-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.cache-status: The status of the cache component. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.capacity-factor: Controls the proportion of entries that will reside on the local node, compared to the other nodes in the cluster.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.consistent-hash-strategy: Defines the consistent hash strategy for the cache.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.attribute-class: The custom store implementation class to use for this cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.custom-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.elapsed-time: Time (in secs) since cache started. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.eviction-component.evictions: The number of cache eviction operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.eviction-component.max-entries: Maximum number of entries in a cache instance. If selected value is not a power of two the actual value will default to the least power of two larger than selected value. -1 means no limit.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.eviction-component.strategy: Sets the cache eviction strategy. Available options are 'UNORDERED', 'FIFO', 'LRU', 'LIRS' and 'NONE' (to disable eviction).
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.expiration-component.interval: Interval (in milliseconds) between subsequent runs to purge expired entries from memory and any cache stores. If you wish to disable the periodic eviction process altogether, set wakeupInterval to -1.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.expiration-component.lifespan: Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.expiration-component.max-idle: Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.path: The system path under which this cache store will persist its entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.relative-to: The system path to which the specified path is relative.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.file-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.hit-ratio: The hit/miss ratio for the cache (hits/hits+misses). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.hits: The number of cache attribute hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.indexing: If enabled, entries will be indexed when they are added to the cache. Indexes will be updated as entries change or are removed.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.indexing-properties: Properties to control indexing behaviour
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.invalidations: The number of cache invalidations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.jndi-name: The jndi-name to which to bind this cache instance.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.l1-lifespan: Maximum lifespan of an entry placed in the L1 cache. This element configures the L1 cache behavior in 'distributed' caches instances. In any other cache modes, this element is ignored.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.acquire-timeout: Maximum time to attempt a particular lock acquisition.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.concurrency-level: Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.current-concurrency-level: The estimated number of concurrently updating threads which this cache can support. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.isolation: Sets the cache locking isolation level.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.number-of-locks-available: The number of locks available to this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.number-of-locks-held: The number of locks currently in use by this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.locking-component.striping: If true, a pool of shared locks is maintained for all entries that need to be locked. Otherwise, a lock is created per entry in the cache. Lock striping helps control memory footprint but may reduce concurrency in the system.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.misses: The number of cache attribute misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mixed-jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.mode: Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.module: The module whose class loader should be used when building this cache’s configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.number-of-entries: The current number of entries in the cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.owners: Number of cluster-wide replicas for each cache entry.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.partition-handling-component.availability: Indicates the current availability of the cache.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.partition-handling-component.enabled: If enabled, the cache will enter degraded mode upon detecting a network partition that threatens the integrity of the cache.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.passivations: The number of cache node passivations (passivating a node from memory to a cache store). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.queue-flush-interval: In ASYNC mode, this attribute controls how often the asynchronous thread used to flush the replication queue runs. This should be a positive integer which represents thread wakeup time in milliseconds.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.queue-size: In ASYNC mode, this attribute can be used to trigger flushing of the queue when it reaches a specific threshold.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.read-write-ratio: The read/write ratio of the cache ((hits+misses)/stores). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.cache: The name of the remote cache to use for this remote store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.remote-servers: A list of remote servers for this cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.socket-timeout: A socket timeout for remote cache communication.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-store.tcp-no-delay: A TCP_NODELAY value for remote cache communication.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remote-timeout: In SYNC mode, the timeout (in ms) used to wait for an acknowledgment when making a remote call, after which the call is aborted and an exception is thrown.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remove-hits: The number of cache attribute remove hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.remove-misses: The number of cache attribute remove misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.replication-count: The number of times data was replicated around the cluster. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.replication-failures: The number of data replication failures. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.segments: Controls the number of hash space segments which is the granularity for key distribution in the cluster. Value must be strictly positive.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.state-transfer-component.chunk-size: The size, in bytes, in which to batch the transfer of cache entries.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.state-transfer-component.enabled: If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.state-transfer-component.timeout: The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.statistics-enabled: If enabled, statistics will be collected for this cache
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.stores: The number of cache attribute put operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.success-ratio: The data replication success ratio (successes/successes+failures). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.time-since-reset: Time (in secs) since cache statistics were reset. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.transaction-component.commits: The number of transaction commits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.transaction-component.locking: The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.transaction-component.mode: Sets the cache transaction mode to one of NONE, NON_XA, NON_DURABLE_XA, FULL_XA.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.transaction-component.prepares: The number of transaction prepares. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.transaction-component.rollbacks: The number of transaction rollbacks. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.transaction-component.stop-timeout: If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing remote and local transactions to finish. The amount of time to wait for is defined by the cache stop timeout.
swarm.infinispan.cache-containers.KEY.expiration-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.expiration-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.activations: The number of cache node activations (bringing a node into memory from a cache store) . May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.async-marshalling: If enabled, this will cause marshalling of entries to be performed asynchronously.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.average-read-time: Average time (in ms) for cache reads. Includes hits and misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.average-replication-time: The average time taken to replicate data around the cluster. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.average-write-time: Average time (in ms) for cache writes. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.binary-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.cache-status: The status of the cache component. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.attribute-class: The custom store implementation class to use for this cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.custom-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.elapsed-time: Time (in secs) since cache started. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.eviction-component.evictions: The number of cache eviction operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.eviction-component.max-entries: Maximum number of entries in a cache instance. If selected value is not a power of two the actual value will default to the least power of two larger than selected value. -1 means no limit.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.eviction-component.strategy: Sets the cache eviction strategy. Available options are 'UNORDERED', 'FIFO', 'LRU', 'LIRS' and 'NONE' (to disable eviction).
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.expiration-component.interval: Interval (in milliseconds) between subsequent runs to purge expired entries from memory and any cache stores. If you wish to disable the periodic eviction process altogether, set wakeupInterval to -1.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.expiration-component.lifespan: Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.expiration-component.max-idle: Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.path: The system path under which this cache store will persist its entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.relative-to: The system path to which the specified path is relative.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.file-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.hit-ratio: The hit/miss ratio for the cache (hits/hits+misses). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.hits: The number of cache attribute hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.indexing: If enabled, entries will be indexed when they are added to the cache. Indexes will be updated as entries change or are removed.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.indexing-properties: Properties to control indexing behaviour
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.invalidations: The number of cache invalidations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.jndi-name: The jndi-name to which to bind this cache instance.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.acquire-timeout: Maximum time to attempt a particular lock acquisition.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.concurrency-level: Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.current-concurrency-level: The estimated number of concurrently updating threads which this cache can support. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.isolation: Sets the cache locking isolation level.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.number-of-locks-available: The number of locks available to this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.number-of-locks-held: The number of locks currently in use by this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.locking-component.striping: If true, a pool of shared locks is maintained for all entries that need to be locked. Otherwise, a lock is created per entry in the cache. Lock striping helps control memory footprint but may reduce concurrency in the system.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.misses: The number of cache attribute misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mixed-jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.mode: Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.module: The module whose class loader should be used when building this cache’s configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.number-of-entries: The current number of entries in the cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.passivations: The number of cache node passivations (passivating a node from memory to a cache store). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.queue-flush-interval: In ASYNC mode, this attribute controls how often the asynchronous thread used to flush the replication queue runs. This should be a positive integer which represents thread wakeup time in milliseconds.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.queue-size: In ASYNC mode, this attribute can be used to trigger flushing of the queue when it reaches a specific threshold.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.read-write-ratio: The read/write ratio of the cache ((hits+misses)/stores). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.cache: The name of the remote cache to use for this remote store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.remote-servers: A list of remote servers for this cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.socket-timeout: A socket timeout for remote cache communication.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-store.tcp-no-delay: A TCP_NODELAY value for remote cache communication.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remote-timeout: In SYNC mode, the timeout (in ms) used to wait for an acknowledgment when making a remote call, after which the call is aborted and an exception is thrown.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remove-hits: The number of cache attribute remove hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.remove-misses: The number of cache attribute remove misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.replication-count: The number of times data was replicated around the cluster. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.replication-failures: The number of data replication failures. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.statistics-enabled: If enabled, statistics will be collected for this cache
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.stores: The number of cache attribute put operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.success-ratio: The data replication success ratio (successes/successes+failures). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.time-since-reset: Time (in secs) since cache statistics were reset. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.transaction-component.commits: The number of transaction commits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.transaction-component.locking: The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.transaction-component.mode: Sets the cache transaction mode to one of NONE, NON_XA, NON_DURABLE_XA, FULL_XA.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.transaction-component.prepares: The number of transaction prepares. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.transaction-component.rollbacks: The number of transaction rollbacks. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.transaction-component.stop-timeout: If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing remote and local transactions to finish. The amount of time to wait for is defined by the cache stop timeout.
swarm.infinispan.cache-containers.KEY.is-coordinator: Set to true if this node is the cluster’s coordinator. May return null if the cache manager is not started.
swarm.infinispan.cache-containers.KEY.jgroups-transport.channel: The channel of this cache container’s transport.
swarm.infinispan.cache-containers.KEY.jgroups-transport.lock-timeout: The timeout for locks for the transport
swarm.infinispan.cache-containers.KEY.jndi-name: The jndi name to which to bind this cache container
swarm.infinispan.cache-containers.KEY.listener-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.listener-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.listener-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.infinispan.cache-containers.KEY.listener-thread-pool.queue-length: The queue length.
swarm.infinispan.cache-containers.KEY.local-address: The local address of the node. May return null if the cache manager is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.activations: The number of cache node activations (bringing a node into memory from a cache store) . May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.average-read-time: Average time (in ms) for cache reads. Includes hits and misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.average-write-time: Average time (in ms) for cache writes. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.binary-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.cache-status: The status of the cache component. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.attribute-class: The custom store implementation class to use for this cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.custom-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.elapsed-time: Time (in secs) since cache started. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.eviction-component.evictions: The number of cache eviction operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.eviction-component.max-entries: Maximum number of entries in a cache instance. If selected value is not a power of two the actual value will default to the least power of two larger than selected value. -1 means no limit.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.eviction-component.strategy: Sets the cache eviction strategy. Available options are 'UNORDERED', 'FIFO', 'LRU', 'LIRS' and 'NONE' (to disable eviction).
swarm.infinispan.cache-containers.KEY.local-caches.KEY.expiration-component.interval: Interval (in milliseconds) between subsequent runs to purge expired entries from memory and any cache stores. If you wish to disable the periodic eviction process altogether, set wakeupInterval to -1.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.expiration-component.lifespan: Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.expiration-component.max-idle: Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.path: The system path under which this cache store will persist its entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.relative-to: The system path to which the specified path is relative.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.file-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.hit-ratio: The hit/miss ratio for the cache (hits/hits+misses). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.hits: The number of cache attribute hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.indexing: If enabled, entries will be indexed when they are added to the cache. Indexes will be updated as entries change or are removed.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.indexing-properties: Properties to control indexing behaviour
swarm.infinispan.cache-containers.KEY.local-caches.KEY.invalidations: The number of cache invalidations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.jndi-name: The jndi-name to which to bind this cache instance.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.acquire-timeout: Maximum time to attempt a particular lock acquisition.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.concurrency-level: Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.current-concurrency-level: The estimated number of concurrently updating threads which this cache can support. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.isolation: Sets the cache locking isolation level.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.number-of-locks-available: The number of locks available to this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.number-of-locks-held: The number of locks currently in use by this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.locking-component.striping: If true, a pool of shared locks is maintained for all entries that need to be locked. Otherwise, a lock is created per entry in the cache. Lock striping helps control memory footprint but may reduce concurrency in the system.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.misses: The number of cache attribute misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.mixed-jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.module: The module whose class loader should be used when building this cache’s configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.number-of-entries: The current number of entries in the cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.passivations: The number of cache node passivations (passivating a node from memory to a cache store). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.read-write-ratio: The read/write ratio of the cache ((hits+misses)/stores). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.cache: The name of the remote cache to use for this remote store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.remote-servers: A list of remote servers for this cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.socket-timeout: A socket timeout for remote cache communication.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remote-store.tcp-no-delay: A TCP_NODELAY value for remote cache communication.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remove-hits: The number of cache attribute remove hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.remove-misses: The number of cache attribute remove misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.statistics-enabled: If enabled, statistics will be collected for this cache
swarm.infinispan.cache-containers.KEY.local-caches.KEY.stores: The number of cache attribute put operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.time-since-reset: Time (in secs) since cache statistics were reset. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.transaction-component.commits: The number of transaction commits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.transaction-component.locking: The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.transaction-component.mode: Sets the cache transaction mode to one of NONE, NON_XA, NON_DURABLE_XA, FULL_XA.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.transaction-component.prepares: The number of transaction prepares. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.transaction-component.rollbacks: The number of transaction rollbacks. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.local-caches.KEY.transaction-component.stop-timeout: If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing remote and local transactions to finish. The amount of time to wait for is defined by the cache stop timeout.
swarm.infinispan.cache-containers.KEY.module: The module whose class loader should be used when building this cache container’s configuration.
swarm.infinispan.cache-containers.KEY.persistence-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.persistence-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.persistence-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.infinispan.cache-containers.KEY.persistence-thread-pool.queue-length: The queue length.
swarm.infinispan.cache-containers.KEY.remote-command-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.remote-command-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.remote-command-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.infinispan.cache-containers.KEY.remote-command-thread-pool.queue-length: The queue length.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.activations: The number of cache node activations (bringing a node into memory from a cache store) . May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.async-marshalling: If enabled, this will cause marshalling of entries to be performed asynchronously.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.average-read-time: Average time (in ms) for cache reads. Includes hits and misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.average-replication-time: The average time taken to replicate data around the cluster. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.average-write-time: Average time (in ms) for cache writes. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backup-for-component.remote-cache: The name of the remote cache for which this cache acts as a backup.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backup-for-component.remote-site: The site of the remote cache for which this cache acts as a backup.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backups-component.backups.KEY.after-failures: Indicates the number of failures after which this backup site should go offline.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backups-component.backups.KEY.enabled: Indicates whether or not this backup site is enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backups-component.backups.KEY.failure-policy: The policy to follow when connectivity to the backup site fails.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backups-component.backups.KEY.min-wait: Indicates the minimum time (in milliseconds) to wait after the max number of failures is reached, after which this backup site should go offline.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backups-component.backups.KEY.strategy: The backup strategy for this cache
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.backups-component.backups.KEY.timeout: The timeout for replicating to the backup site.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.binary-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.cache-status: The status of the cache component. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.attribute-class: The custom store implementation class to use for this cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.custom-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.elapsed-time: Time (in secs) since cache started. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.eviction-component.evictions: The number of cache eviction operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.eviction-component.max-entries: Maximum number of entries in a cache instance. If selected value is not a power of two the actual value will default to the least power of two larger than selected value. -1 means no limit.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.eviction-component.strategy: Sets the cache eviction strategy. Available options are 'UNORDERED', 'FIFO', 'LRU', 'LIRS' and 'NONE' (to disable eviction).
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.expiration-component.interval: Interval (in milliseconds) between subsequent runs to purge expired entries from memory and any cache stores. If you wish to disable the periodic eviction process altogether, set wakeupInterval to -1.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.expiration-component.lifespan: Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.expiration-component.max-idle: Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.path: The system path under which this cache store will persist its entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.relative-to: The system path to which the specified path is relative.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.file-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.hit-ratio: The hit/miss ratio for the cache (hits/hits+misses). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.hits: The number of cache attribute hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.indexing: If enabled, entries will be indexed when they are added to the cache. Indexes will be updated as entries change or are removed.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.indexing-properties: Properties to control indexing behaviour
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.invalidations: The number of cache invalidations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.jndi-name: The jndi-name to which to bind this cache instance.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.acquire-timeout: Maximum time to attempt a particular lock acquisition.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.concurrency-level: Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.current-concurrency-level: The estimated number of concurrently updating threads which this cache can support. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.isolation: Sets the cache locking isolation level.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.number-of-locks-available: The number of locks available to this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.number-of-locks-held: The number of locks currently in use by this cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.locking-component.striping: If true, a pool of shared locks is maintained for all entries that need to be locked. Otherwise, a lock is created per entry in the cache. Lock striping helps control memory footprint but may reduce concurrency in the system.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.misses: The number of cache attribute misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-keyed-table: Defines a table used to store cache entries whose keys cannot be expressed as strings.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.binary-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.data-source: References the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.datasource: The jndi name of the data source used to connect to this store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.dialect: The dialect of this datastore.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-keyed-table: Defines a table used to store persistent cache entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-table.batch-size: For DB inserts, the batch size determines how many inserts are batched together.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-table.data-column: A database column to hold cache entry data.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-table.fetch-size: For DB queries, the fetch size will be used to set the fetch size on ResultSets.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-table.id-column: A database column to hold cache entry ids.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-table.prefix: The prefix for the database table name.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mixed-jdbc-store.string-table.timestamp-column: A database column to hold cache entry timestamps.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.mode: Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.module: The module whose class loader should be used when building this cache’s configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.number-of-entries: The current number of entries in the cache. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.partition-handling-component.availability: Indicates the current availability of the cache.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.partition-handling-component.enabled: If enabled, the cache will enter degraded mode upon detecting a network partition that threatens the integrity of the cache.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.passivations: The number of cache node passivations (passivating a node from memory to a cache store). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.queue-flush-interval: In ASYNC mode, this attribute controls how often the asynchronous thread used to flush the replication queue runs. This should be a positive integer which represents thread wakeup time in milliseconds.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.queue-size: In ASYNC mode, this attribute can be used to trigger flushing of the queue when it reaches a specific threshold.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.read-write-ratio: The read/write ratio of the cache ((hits+misses)/stores). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.behind-write.flush-lock-timeout: Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.behind-write.modification-queue-size: Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.behind-write.shutdown-timeout: Timeout in milliseconds to stop the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.behind-write.thread-pool-size: Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.cache: The name of the remote cache to use for this remote store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.cache-loader-loads: The number of cache loader node loads. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.cache-loader-misses: The number of cache loader node misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.fetch-state: If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.passivation: If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.preload: If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.properties: A list of cache store properties.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.properties.KEY.value: The value of the cache store property.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.purge: If true, purges this cache store when it starts up.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.remote-servers: A list of remote servers for this cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.shared: This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.singleton: If true, the singleton store cache store is enabled. SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.socket-timeout: A socket timeout for remote cache communication.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-store.tcp-no-delay: A TCP_NODELAY value for remote cache communication.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remote-timeout: In SYNC mode, the timeout (in ms) used to wait for an acknowledgment when making a remote call, after which the call is aborted and an exception is thrown.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remove-hits: The number of cache attribute remove hits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.remove-misses: The number of cache attribute remove misses. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.replication-count: The number of times data was replicated around the cluster. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.replication-failures: The number of data replication failures. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.state-transfer-component.chunk-size: The size, in bytes, in which to batch the transfer of cache entries.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.state-transfer-component.enabled: If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.state-transfer-component.timeout: The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.statistics-enabled: If enabled, statistics will be collected for this cache
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.stores: The number of cache attribute put operations. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.success-ratio: The data replication success ratio (successes/successes+failures). May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.time-since-reset: Time (in secs) since cache statistics were reset. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.transaction-component.commits: The number of transaction commits. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.transaction-component.locking: The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.transaction-component.mode: Sets the cache transaction mode to one of NONE, NON_XA, NON_DURABLE_XA, FULL_XA.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.transaction-component.prepares: The number of transaction prepares. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.transaction-component.rollbacks: The number of transaction rollbacks. May return null if the cache is not started.
swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.transaction-component.stop-timeout: If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing remote and local transactions to finish. The amount of time to wait for is defined by the cache stop timeout.
swarm.infinispan.cache-containers.KEY.state-transfer-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.state-transfer-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.state-transfer-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.infinispan.cache-containers.KEY.state-transfer-thread-pool.queue-length: The queue length.
swarm.infinispan.cache-containers.KEY.statistics-enabled: If enabled, statistics will be collected for this cache container
swarm.infinispan.cache-containers.KEY.transport-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.infinispan.cache-containers.KEY.transport-thread-pool.max-threads: The maximum thread pool size.
swarm.infinispan.cache-containers.KEY.transport-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.infinispan.cache-containers.KEY.transport-thread-pool.queue-length: The queue length.
swarm.infinispan.default-fraction: (not yet documented)

6.23. IO

Primarily an internal fraction supporting I/O activities for higher-level fractions.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>io</artifactId>
</dependency>

Configuration

swarm.io.buffer-pools.KEY.buffer-size: The size of each buffer slice in bytes, if not set optimal value is calculated based on available RAM resources in your system.
swarm.io.buffer-pools.KEY.buffers-per-slice: How many buffers per slice, if not set optimal value is calculated based on available RAM resources in your system.
swarm.io.buffer-pools.KEY.direct-buffers: Does the buffer pool use direct buffers, some platforms don’t support direct buffers
swarm.io.workers.KEY.core-pool-size: Minimum number of threads to keep in the underlying java.util.concurrent.ThreadPoolExecutor even if they are idle. Threads over this limit will be terminated over time specified by task-keepalive attribute.
swarm.io.workers.KEY.io-thread-count: I/O thread count
swarm.io.workers.KEY.io-threads: Specify the number of I/O threads to create for the worker. If not specified, a default will be chosen, which is calculated by cpuCount * 2
swarm.io.workers.KEY.max-pool-size: The maximum number of threads to allow in the thread pool. Depending on implementation, when this limit is reached, tasks which cannot be queued may be rejected.
swarm.io.workers.KEY.outbound-bind-address.KEY.bind-address: The address to bind to when the destination address matches
swarm.io.workers.KEY.outbound-bind-address.KEY.bind-port: The port number to bind to when the destination address matches
swarm.io.workers.KEY.outbound-bind-address.KEY.match: The destination address range to match
swarm.io.workers.KEY.queue-size: An estimate of the number of tasks in the worker queue.
swarm.io.workers.KEY.servers.KEY.connection-count: Estimate of the current connection count
swarm.io.workers.KEY.servers.KEY.connection-limit-high-water-mark: If the connection count hits this number, no new connections will be accepted until the count drops below the low-water mark.
swarm.io.workers.KEY.servers.KEY.connection-limit-low-water-mark: If the connection count has previously hit the high water mark, once it drops back down below this count, connections will be accepted again.
swarm.io.workers.KEY.shutdown-requested: True is shutdown of the pool was requested
swarm.io.workers.KEY.stack-size: The stack size (in bytes) to attempt to use for worker threads.
swarm.io.workers.KEY.task-keepalive: Specify the number of milliseconds to keep non-core task threads alive.
swarm.io.workers.KEY.task-max-threads: Specify the maximum number of threads for the worker task thread pool.If not set, default value used which is calculated by formula cpuCount * 16,as long as MaxFileDescriptorCount jmx property allows that number, otherwise calculation takes max into account to adjust it accordingly.

6.24. Jaeger

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaeger</artifactId>
</dependency>

Configuration

thorntail.jaeger.agent-host: The hostname for communicating with agent via UDP
thorntail.jaeger.agent-port: The port for communicating with agent via UDP
thorntail.jaeger.enable-b3-header-propagation: Whether to enable propagation of B3 headers in the configured Tracer. By default this is false.
thorntail.jaeger.password: Password to send as part of "Basic" authentication to the endpoint
thorntail.jaeger.remote-reporter-http-endpoint: Remote Reporter HTTP endpoint for Jaeger collector, such as http://jaeger-collector.istio-system:14268/api/traces
thorntail.jaeger.reporter-flush-interval: The reporter’s flush interval (ms)
thorntail.jaeger.reporter-log-spans: Whether the reporter should also log the spans
thorntail.jaeger.reporter-max-queue-size: The reporter’s maximum queue size
thorntail.jaeger.sampler-manager-host: The host name and port when using the remote controlled sampler
thorntail.jaeger.sampler-parameter: The sampler parameter (number). Ex.: 1
thorntail.jaeger.sampler-type: The sampler type. Ex.: const
thorntail.jaeger.service-name: The service name. Required (via this parameter, system property or env var). Ex.: order-manager
thorntail.jaeger.user: Username to send as part of "Basic" authentication to the endpoint

6.25. JavaFX

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>javafx</artifactId>
</dependency>

6.26. JAX-RS

Provides support for building RESTful web services according to JSR-311.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaxrs</artifactId>
</dependency>

Configuration

thorntail.deployment.KEY.jaxrs.application-path: Set the JAX-RS application path. If set, Thorntail will automatically generate a JAX-RS Application class and use this value as the @ApplicationPath

6.26.1. JAX-RS + CDI

An internal fraction providing integration between JAX-RS and CDI.

For more information, see the JAX-RS and CDI fraction documentation.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaxrs-cdi</artifactId>
</dependency>

6.26.2. JAX-RS + JAXB

Provides support within JAX-RS applications for the XML binding framework according to JSR-31 and JSR-222.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaxrs-jaxb</artifactId>
</dependency>

6.26.3. JAX-RS + JSON-P

Provides support within JAX-RS application for JSON processing according to JSR-374.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaxrs-jsonp</artifactId>
</dependency>

6.26.4. JAX-RS + Multipart

Provides support within JAX-RS application for MIME multipart form processing.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaxrs-multipart</artifactId>
</dependency>

6.26.5. JAX-RS + Validator

Provides integration and support between JAX-RS applications and Hibernate Validator.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jaxrs-validator</artifactId>
</dependency>

6.27. JCA

Provides support for the Java Connector Architecture (JCA) according to JSR 322.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jca</artifactId>
</dependency>

Configuration

swarm.jca.archive-validation.enabled: Specify whether archive validation is enabled
swarm.jca.archive-validation.fail-on-error: Should an archive validation error report fail the deployment
swarm.jca.archive-validation.fail-on-warn: Should an archive validation warning report fail the deployment
swarm.jca.bean-validation.enabled: Specify whether bean validation is enabled
swarm.jca.bootstrap-contexts.KEY.name: The name of the BootstrapContext
swarm.jca.bootstrap-contexts.KEY.workmanager: The WorkManager instance for the BootstrapContext
swarm.jca.cached-connection-manager.debug: Enable/disable debug information logging
swarm.jca.cached-connection-manager.error: Enable/disable error information logging
swarm.jca.cached-connection-manager.ignore-unknown-connections: Do not cache unknown connections
swarm.jca.cached-connection-manager.install: Enable/disable the cached connection manager valve and interceptor
swarm.jca.distributed-workmanagers.KEY.elytron-enabled: Enables Elytron security for this workmanager.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.allow-core-timeout: Whether core threads may time out.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.core-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.current-thread-count: The current number of threads in the pool.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.handoff-executor: An executor to delegate tasks to in the event that a task cannot be accepted. If not specified, tasks that cannot be accepted will be silently discarded.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.keepalive-time: Used to specify the amount of time that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.largest-thread-count: The largest number of threads that have ever simultaneously been in the pool.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.max-threads: The maximum thread pool size.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.name: The name of the thread pool.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.queue-length: The queue length.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.queue-size: The queue size.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.rejected-count: The number of tasks that have been passed to the handoff-executor (if one is specified) or discarded.
swarm.jca.distributed-workmanagers.KEY.long-running-threads.KEY.thread-factory: Specifies the name of a specific thread factory to use to create worker threads. If not defined an appropriate default thread factory will be used.
swarm.jca.distributed-workmanagers.KEY.name: The name of the DistributedWorkManager
swarm.jca.distributed-workmanagers.KEY.policy: The policy decides when to redistribute a Work instance
swarm.jca.distributed-workmanagers.KEY.policy-options: List of policy’s options key/value pairs
swarm.jca.distributed-workmanagers.KEY.selector: The selector decides to which nodes in the network to redistribute the Work instance to
swarm.jca.distributed-workmanagers.KEY.selector-options: List of selector’s options key/value pairs
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.allow-core-timeout: Whether core threads may time out.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.core-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.current-thread-count: The current number of threads in the pool.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.handoff-executor: An executor to delegate tasks to in the event that a task cannot be accepted. If not specified, tasks that cannot be accepted will be silently discarded.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.keepalive-time: Used to specify the amount of time that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.largest-thread-count: The largest number of threads that have ever simultaneously been in the pool.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.max-threads: The maximum thread pool size.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.name: The name of the thread pool.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.queue-length: The queue length.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.queue-size: The queue size.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.rejected-count: The number of tasks that have been passed to the handoff-executor (if one is specified) or discarded.
swarm.jca.distributed-workmanagers.KEY.short-running-threads.KEY.thread-factory: Specifies the name of a specific thread factory to use to create worker threads. If not defined an appropriate default thread factory will be used.
swarm.jca.tracer.enabled: Specify whether tracer is enabled
swarm.jca.workmanagers.KEY.elytron-enabled: Enables Elytron security for this workmanager.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.allow-core-timeout: Whether core threads may time out.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.core-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.current-thread-count: The current number of threads in the pool.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.handoff-executor: An executor to delegate tasks to in the event that a task cannot be accepted. If not specified, tasks that cannot be accepted will be silently discarded.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.keepalive-time: Used to specify the amount of time that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.largest-thread-count: The largest number of threads that have ever simultaneously been in the pool.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.max-threads: The maximum thread pool size.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.name: The name of the thread pool.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.queue-length: The queue length.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.queue-size: The queue size.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.rejected-count: The number of tasks that have been passed to the handoff-executor (if one is specified) or discarded.
swarm.jca.workmanagers.KEY.long-running-threads.KEY.thread-factory: Specifies the name of a specific thread factory to use to create worker threads. If not defined an appropriate default thread factory will be used.
swarm.jca.workmanagers.KEY.name: The name of the WorkManager
swarm.jca.workmanagers.KEY.short-running-threads.KEY.allow-core-timeout: Whether core threads may time out.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.core-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.current-thread-count: The current number of threads in the pool.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.handoff-executor: An executor to delegate tasks to in the event that a task cannot be accepted. If not specified, tasks that cannot be accepted will be silently discarded.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.keepalive-time: Used to specify the amount of time that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.largest-thread-count: The largest number of threads that have ever simultaneously been in the pool.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.max-threads: The maximum thread pool size.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.name: The name of the thread pool.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.queue-length: The queue length.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.queue-size: The queue size.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.rejected-count: The number of tasks that have been passed to the handoff-executor (if one is specified) or discarded.
swarm.jca.workmanagers.KEY.short-running-threads.KEY.thread-factory: Specifies the name of a specific thread factory to use to create worker threads. If not defined an appropriate default thread factory will be used.

6.28. JBoss Diagnostic Reporting

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jdr</artifactId>
</dependency>

6.29. JGroups

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jgroups</artifactId>
</dependency>

Configuration

swarm.jgroups.channels.KEY.address: The IP address of the channel.
swarm.jgroups.channels.KEY.address-as-uuid: The address of the channel as a UUID.
swarm.jgroups.channels.KEY.cluster: The cluster name of the JGroups channel. If undefined, the name of the channel will be used.
swarm.jgroups.channels.KEY.discard-own-messages: If true, do not receive messages sent by this node (ourself).
swarm.jgroups.channels.KEY.forks.KEY.protocols.KEY.module: The module with which to resolve the protocol type.
swarm.jgroups.channels.KEY.forks.KEY.protocols.KEY.properties: The properties of this protocol.
swarm.jgroups.channels.KEY.forks.KEY.protocols.KEY.properties.KEY.value: The value of a protocol property.
swarm.jgroups.channels.KEY.forks.KEY.protocols.KEY.socket-binding: The socket binding specification for this protocol layer, used to specify IP interfaces and ports for communication.
swarm.jgroups.channels.KEY.forks.KEY.protocols.KEY.statistics-enabled: Indicates whether or not this protocol will collect statistics overriding stack configuration.
swarm.jgroups.channels.KEY.module: The module from which to load channel services
swarm.jgroups.channels.KEY.num-tasks-in-timer: The current number of timer tasks.
swarm.jgroups.channels.KEY.num-timer-threads: The number of timer threads.
swarm.jgroups.channels.KEY.received-bytes: The number of bytes received by this channel.
swarm.jgroups.channels.KEY.received-messages: The number of messages received by this channel.
swarm.jgroups.channels.KEY.sent-bytes: The number of bytes sent by this channel.
swarm.jgroups.channels.KEY.sent-messages: The number of messages sent by this channel.
swarm.jgroups.channels.KEY.stack: The protocol stack of the JGroups channel
swarm.jgroups.channels.KEY.state: The state of the channel (OPEN, CONNECTING, CONNECTED, CLOSED).
swarm.jgroups.channels.KEY.statistics-enabled: If enabled, collect channel statistics.
swarm.jgroups.channels.KEY.stats-enabled: If enabled, collect channel statistics.
swarm.jgroups.channels.KEY.version: The JGroups software version.
swarm.jgroups.channels.KEY.view: The channel’s view of group membership.
swarm.jgroups.default-channel: The default JGroups channel.
swarm.jgroups.default-stack: The default JGroups protocol stack.
swarm.jgroups.stacks.KEY.RELAY2.module: The module with which to resolve the protocol type.
swarm.jgroups.stacks.KEY.RELAY2.properties: The properties of this protocol.
swarm.jgroups.stacks.KEY.RELAY2.remote-sites.KEY.channel: The name of the bridge channel used to communicate with this remote site.
swarm.jgroups.stacks.KEY.RELAY2.site: The name of the local site.
swarm.jgroups.stacks.KEY.RELAY2.statistics-enabled: Indicates whether or not this protocol will collect statistics overriding stack configuration.
swarm.jgroups.stacks.KEY.protocols.KEY.module: The module with which to resolve the protocol type.
swarm.jgroups.stacks.KEY.protocols.KEY.properties: The properties of this protocol.
swarm.jgroups.stacks.KEY.protocols.KEY.properties.KEY.value: The value of a protocol property.
swarm.jgroups.stacks.KEY.protocols.KEY.socket-binding: The socket binding specification for this protocol layer, used to specify IP interfaces and ports for communication.
swarm.jgroups.stacks.KEY.protocols.KEY.statistics-enabled: Indicates whether or not this protocol will collect statistics overriding stack configuration.
swarm.jgroups.stacks.KEY.statistics-enabled: Indicates whether or not all protocols in the stack will collect statistics by default.
swarm.jgroups.stacks.KEY.transports.KEY.default-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jgroups.stacks.KEY.transports.KEY.default-thread-pool.max-threads: The maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.default-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.default-thread-pool.queue-length: The queue length.
swarm.jgroups.stacks.KEY.transports.KEY.diagnostics-socket-binding: The diagnostics socket binding specification for this protocol layer, used to specify IP interfaces and ports for communication.
swarm.jgroups.stacks.KEY.transports.KEY.internal-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jgroups.stacks.KEY.transports.KEY.internal-thread-pool.max-threads: The maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.internal-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.internal-thread-pool.queue-length: The queue length.
swarm.jgroups.stacks.KEY.transports.KEY.machine: The machine (i.e. host) identifier for this node. Used by Infinispan topology-aware consistent hash.
swarm.jgroups.stacks.KEY.transports.KEY.module: The module with which to resolve the protocol type.
swarm.jgroups.stacks.KEY.transports.KEY.oob-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jgroups.stacks.KEY.transports.KEY.oob-thread-pool.max-threads: The maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.oob-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.oob-thread-pool.queue-length: The queue length.
swarm.jgroups.stacks.KEY.transports.KEY.properties: The properties of this protocol.
swarm.jgroups.stacks.KEY.transports.KEY.properties.KEY.value: The value of a protocol property.
swarm.jgroups.stacks.KEY.transports.KEY.rack: The rack (i.e. server rack) identifier for this node. Used by Infinispan topology-aware consistent hash.
swarm.jgroups.stacks.KEY.transports.KEY.shared: If true, the underlying transport is shared by all channels using this stack.
swarm.jgroups.stacks.KEY.transports.KEY.site: The site (i.e. data centre) identifier for this node. Used by Infinispan topology-aware consistent hash.
swarm.jgroups.stacks.KEY.transports.KEY.socket-binding: The socket binding specification for this protocol layer, used to specify IP interfaces and ports for communication.
swarm.jgroups.stacks.KEY.transports.KEY.statistics-enabled: Indicates whether or not this protocol will collect statistics overriding stack configuration.
swarm.jgroups.stacks.KEY.transports.KEY.timer-thread-pool.keepalive-time: Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
swarm.jgroups.stacks.KEY.transports.KEY.timer-thread-pool.max-threads: The maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.timer-thread-pool.min-threads: The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
swarm.jgroups.stacks.KEY.transports.KEY.timer-thread-pool.queue-length: The queue length.
thorntail.default.multicast.address: Default multicast address for JGroups

6.30. JMX

Provides support for Java Management Extensions (JMX) according to JSR-3.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jmx</artifactId>
</dependency>

Configuration

swarm.jmx.audit-log-configuration.enabled: Whether audit logging is enabled.
swarm.jmx.audit-log-configuration.log-boot: Whether operations should be logged on server boot.
swarm.jmx.audit-log-configuration.log-read-only: Whether operations that do not modify the configuration or any runtime services should be logged.
swarm.jmx.expression-expose-model.domain-name: The domain name to use for the 'expression' model controller JMX facade in the MBeanServer.
swarm.jmx.jmx-remoting-connector.use-management-endpoint: If true the connector will use the management endpoint, otherwise it will use the remoting subsystem one
swarm.jmx.non-core-mbean-sensitivity: Whether or not core MBeans, i.e. mbeans not coming from the model controller, should be considered sensitive.
swarm.jmx.resolved-expose-model.domain-name: The domain name to use for the 'resolved' model controller JMX facade in the MBeanServer.
swarm.jmx.resolved-expose-model.proper-property-format: If false, PROPERTY type attributes are represented as a DMR string, this is the legacy behaviour. If true, PROPERTY type attributes are represented by a composite type where the key is a string, and the value has the same type as the property in the underlying model.
swarm.jmx.show-model: Alias for the existence of the 'resolved' model controller jmx facade. When writing, if set to 'true' it will add the 'resolved' model controller jmx facade resource with the default domain name.

6.31. Jolokia

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jolokia</artifactId>
</dependency>

Configuration

swarm.jolokia.context: Context path for the Jolokia endpoints
swarm.jolokia.jolokia-war-preparer: (not yet documented)

6.32. JOSE Signing and Encryption Support

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jose</artifactId>
</dependency>

Configuration

swarm.jose.content-encryption-algorithm: Content encryption algorithm: : see RFC7518, Section 5
swarm.jose.encryption-format: Encryption format: COMPACT (default) or JSON (support is optional)
swarm.jose.encryption-key-alias: Alias to the encryption key entry in the keystore
swarm.jose.encryption-key-password: Password to the encryption private key
swarm.jose.include-encryption-key-alias: Include the encryption key alias as the JOSE 'kid' header (defaults to true)
swarm.jose.key-encryption-algorithm: Key encryption algorithm: see RFC7518, Section 4
swarm.jose.keystore-password: Password to the keystore
swarm.jose.keystore-path: Path to the keystore, only the classpath is currently supported
swarm.jose.keystore-type: Keystore type: Java KeyStore type or 'jwk' - JSON Web Key store, see RFC7517, section 5
swarm.jose.signature-algorithm: Signature algorithm: see RFC7518, Section 3
swarm.jose.signature-data-detached: Signature detached mode: true - the data is in the sequence (default), false - outside
swarm.jose.signature-data-encoding: Signature data encoding mode: true - Base64Url (default), false - clear text
swarm.jose.signature-format: Signature format: COMPACT (default) or JSON (support is optional)
swarm.jose.signature-key-alias: Alias to the signature key entry in the keystore
swarm.jose.signature-key-password: Password to the signature private key
thorntail.jose.encryption.contentAlgorithm: Content encryption algorithm: : see RFC7518, Section 5
thorntail.jose.encryption.format: Encryption format: COMPACT (default) or JSON (support is optional)
thorntail.jose.encryption.include.alias: Include the encryption key alias as the JOSE 'kid' header (defaults to true)
thorntail.jose.encryption.key.alias: Alias to the encryption key entry in the keystore
thorntail.jose.encryption.key.password: Password to the encryption private key
thorntail.jose.encryption.keyAlgorithm: Key encryption algorithm: see RFC7518, Section 4
thorntail.jose.keystore.password: Password to the keystore
thorntail.jose.keystore.path: Path to the keystore, only the classpath is currently supported
thorntail.jose.keystore.type: Keystore type: Java KeyStore type or 'jwk' - JSON Web Key store, see RFC7517, section 5
thorntail.jose.signature.algorithm: Signature algorithm: see RFC7518, Section 3
thorntail.jose.signature.data-detached: Signature detached mode: true - the data is in the sequence (default), false - outside
thorntail.jose.signature.data-encoding: Signature data encoding mode: true - Base64Url (default), false - clear text
thorntail.jose.signature.format: Signature format: COMPACT (default) or JSON (support is optional)
thorntail.jose.signature.key.alias: Alias to the signature key entry in the keystore
thorntail.jose.signature.key.password: Password to the signature private key

6.33. JPA

Provides support for the Java Persistence API according to JSR-220.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jpa</artifactId>
</dependency>

Configuration

swarm.jpa.default-datasource: The name of the default global datasource.
swarm.jpa.default-extended-persistence-inheritance: Controls how JPA extended persistence context (XPC) inheritance is performed. 'DEEP' shares the extended persistence context at top bean level. 'SHALLOW' the extended persistece context is only shared with the parent bean (never with sibling beans).

6.33.1. JPA EclipseLink

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jpa-eclipselink</artifactId>
</dependency>

6.33.2. JPA Spatial Extensions

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jpa-spatial</artifactId>
</dependency>

6.34. JSF

Provides support for JavaServer Faces according to JSR-344.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jsf</artifactId>
</dependency>

Configuration

swarm.jsf.default-jsf-impl-slot: Default JSF implementation slot

6.35. JSON-P

Provides support for JSON Processing according to JSR-353.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>jsonp</artifactId>
</dependency>

6.36. Keycloak

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>keycloak</artifactId>
</dependency>

Configuration

swarm.keycloak.realms.KEY.allow-any-hostname: SSL Setting
swarm.keycloak.realms.KEY.always-refresh-token: Refresh token on every single web request
swarm.keycloak.realms.KEY.auth-server-url: Base URL of the Realm Auth Server
swarm.keycloak.realms.KEY.auth-server-url-for-backend-requests: URL to use to make background calls to auth server
swarm.keycloak.realms.KEY.autodetect-bearer-only: autodetect bearer-only requests
swarm.keycloak.realms.KEY.client-key-password: n/a
swarm.keycloak.realms.KEY.client-keystore: n/a
swarm.keycloak.realms.KEY.client-keystore-password: n/a
swarm.keycloak.realms.KEY.connection-pool-size: Connection pool size for the client used by the adapter
swarm.keycloak.realms.KEY.cors-allowed-headers: CORS allowed headers
swarm.keycloak.realms.KEY.cors-allowed-methods: CORS allowed methods
swarm.keycloak.realms.KEY.cors-exposed-headers: CORS exposed headers
swarm.keycloak.realms.KEY.cors-max-age: CORS max-age header
swarm.keycloak.realms.KEY.disable-trust-manager: Adapter will not use a trust manager when making adapter HTTPS requests
swarm.keycloak.realms.KEY.enable-cors: Enable Keycloak CORS support
swarm.keycloak.realms.KEY.expose-token: Enable secure URL that exposes access token
swarm.keycloak.realms.KEY.ignore-oauth-query-parameter: disable query parameter parsing for access_token
swarm.keycloak.realms.KEY.principal-attribute: token attribute to use to set Principal name
swarm.keycloak.realms.KEY.realm-public-key: Public key of the realm
swarm.keycloak.realms.KEY.register-node-at-startup: Cluster setting
swarm.keycloak.realms.KEY.register-node-period: how often to re-register node
swarm.keycloak.realms.KEY.ssl-required: Specify if SSL is required (valid values are all, external and none)
swarm.keycloak.realms.KEY.token-store: cookie or session storage for auth session data
swarm.keycloak.realms.KEY.truststore: Truststore used for adapter client HTTPS requests
swarm.keycloak.realms.KEY.truststore-password: Password of the Truststore
swarm.keycloak.secure-deployments.KEY.allow-any-hostname: SSL Setting
swarm.keycloak.secure-deployments.KEY.always-refresh-token: Refresh token on every single web request
swarm.keycloak.secure-deployments.KEY.auth-server-url: Base URL of the Realm Auth Server
swarm.keycloak.secure-deployments.KEY.auth-server-url-for-backend-requests: URL to use to make background calls to auth server
swarm.keycloak.secure-deployments.KEY.autodetect-bearer-only: autodetect bearer-only requests
swarm.keycloak.secure-deployments.KEY.bearer-only: Bearer Token Auth only
swarm.keycloak.secure-deployments.KEY.client-key-password: n/a
swarm.keycloak.secure-deployments.KEY.client-keystore: n/a
swarm.keycloak.secure-deployments.KEY.client-keystore-password: n/a
swarm.keycloak.secure-deployments.KEY.connection-pool-size: Connection pool size for the client used by the adapter
swarm.keycloak.secure-deployments.KEY.cors-allowed-headers: CORS allowed headers
swarm.keycloak.secure-deployments.KEY.cors-allowed-methods: CORS allowed methods
swarm.keycloak.secure-deployments.KEY.cors-exposed-headers: CORS exposed headers
swarm.keycloak.secure-deployments.KEY.cors-max-age: CORS max-age header
swarm.keycloak.secure-deployments.KEY.credentials.KEY.value: Credential value
swarm.keycloak.secure-deployments.KEY.disable-trust-manager: Adapter will not use a trust manager when making adapter HTTPS requests
swarm.keycloak.secure-deployments.KEY.enable-basic-auth: Enable Basic Authentication
swarm.keycloak.secure-deployments.KEY.enable-cors: Enable Keycloak CORS support
swarm.keycloak.secure-deployments.KEY.expose-token: Enable secure URL that exposes access token
swarm.keycloak.secure-deployments.KEY.ignore-oauth-query-parameter: disable query parameter parsing for access_token
swarm.keycloak.secure-deployments.KEY.min-time-between-jwks-requests: If adapter recognize token signed by unknown public key, it will try to download new public key from keycloak server. However it won’t try to download if already tried it in less than 'min-time-between-jwks-requests' seconds
swarm.keycloak.secure-deployments.KEY.principal-attribute: token attribute to use to set Principal name
swarm.keycloak.secure-deployments.KEY.public-client: Public client
swarm.keycloak.secure-deployments.KEY.realm: Keycloak realm
swarm.keycloak.secure-deployments.KEY.realm-public-key: Public key of the realm
swarm.keycloak.secure-deployments.KEY.redirect-rewrite-rules.KEY.value: redirect-rewrite-rule value
swarm.keycloak.secure-deployments.KEY.register-node-at-startup: Cluster setting
swarm.keycloak.secure-deployments.KEY.register-node-period: how often to re-register node
swarm.keycloak.secure-deployments.KEY.resource: Application name
swarm.keycloak.secure-deployments.KEY.ssl-required: Specify if SSL is required (valid values are all, external and none)
swarm.keycloak.secure-deployments.KEY.token-minimum-time-to-live: The adapter will refresh the token if the current token is expired OR will expire in 'token-minimum-time-to-live' seconds or less
swarm.keycloak.secure-deployments.KEY.token-store: cookie or session storage for auth session data
swarm.keycloak.secure-deployments.KEY.truststore: Truststore used for adapter client HTTPS requests
swarm.keycloak.secure-deployments.KEY.truststore-password: Password of the Truststore
swarm.keycloak.secure-deployments.KEY.turn-off-change-session-id-on-login: The session id is changed by default on a successful login. Change this to true if you want to turn this off
swarm.keycloak.secure-deployments.KEY.use-resource-role-mappings: Use resource level permissions from token
swarm.keycloak.secure-servers.KEY.allow-any-hostname: SSL Setting
swarm.keycloak.secure-servers.KEY.always-refresh-token: Refresh token on every single web request
swarm.keycloak.secure-servers.KEY.auth-server-url: Base URL of the Realm Auth Server
swarm.keycloak.secure-servers.KEY.auth-server-url-for-backend-requests: URL to use to make background calls to auth server
swarm.keycloak.secure-servers.KEY.autodetect-bearer-only: autodetect bearer-only requests
swarm.keycloak.secure-servers.KEY.bearer-only: Bearer Token Auth only
swarm.keycloak.secure-servers.KEY.client-key-password: n/a
swarm.keycloak.secure-servers.KEY.client-keystore: n/a
swarm.keycloak.secure-servers.KEY.client-keystore-password: n/a
swarm.keycloak.secure-servers.KEY.connection-pool-size: Connection pool size for the client used by the adapter
swarm.keycloak.secure-servers.KEY.cors-allowed-headers: CORS allowed headers
swarm.keycloak.secure-servers.KEY.cors-allowed-methods: CORS allowed methods
swarm.keycloak.secure-servers.KEY.cors-exposed-headers: CORS exposed headers
swarm.keycloak.secure-servers.KEY.cors-max-age: CORS max-age header
swarm.keycloak.secure-servers.KEY.credentials.KEY.value: Credential value
swarm.keycloak.secure-servers.KEY.disable-trust-manager: Adapter will not use a trust manager when making adapter HTTPS requests
swarm.keycloak.secure-servers.KEY.enable-basic-auth: Enable Basic Authentication
swarm.keycloak.secure-servers.KEY.enable-cors: Enable Keycloak CORS support
swarm.keycloak.secure-servers.KEY.expose-token: Enable secure URL that exposes access token
swarm.keycloak.secure-servers.KEY.ignore-oauth-query-parameter: disable query parameter parsing for access_token
swarm.keycloak.secure-servers.KEY.min-time-between-jwks-requests: If adapter recognize token signed by unknown public key, it will try to download new public key from keycloak server. However it won’t try to download if already tried it in less than 'min-time-between-jwks-requests' seconds
swarm.keycloak.secure-servers.KEY.principal-attribute: token attribute to use to set Principal name
swarm.keycloak.secure-servers.KEY.public-client: Public client
swarm.keycloak.secure-servers.KEY.realm: Keycloak realm
swarm.keycloak.secure-servers.KEY.realm-public-key: Public key of the realm
swarm.keycloak.secure-servers.KEY.redirect-rewrite-rules.KEY.value: redirect-rewrite-rule value
swarm.keycloak.secure-servers.KEY.register-node-at-startup: Cluster setting
swarm.keycloak.secure-servers.KEY.register-node-period: how often to re-register node
swarm.keycloak.secure-servers.KEY.resource: Application name
swarm.keycloak.secure-servers.KEY.ssl-required: Specify if SSL is required (valid values are all, external and none)
swarm.keycloak.secure-servers.KEY.token-minimum-time-to-live: The adapter will refresh the token if the current token is expired OR will expire in 'token-minimum-time-to-live' seconds or less
swarm.keycloak.secure-servers.KEY.token-store: cookie or session storage for auth session data
swarm.keycloak.secure-servers.KEY.truststore: Truststore used for adapter client HTTPS requests
swarm.keycloak.secure-servers.KEY.truststore-password: Password of the Truststore
swarm.keycloak.secure-servers.KEY.turn-off-change-session-id-on-login: The session id is changed by default on a successful login. Change this to true if you want to turn this off
swarm.keycloak.secure-servers.KEY.use-resource-role-mappings: Use resource level permissions from token
thorntail.keycloak.json.path: Path to Keycloak adapter configuration
thorntail.keycloak.multitenancy.paths: Map of the relative request paths to Keycloak adapter configuration locations

6.36.1. Keycloak Server

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>keycloak-server</artifactId>
</dependency>

Configuration

swarm.keycloak-server.master-realm-name: The name of the master admin realm.
swarm.keycloak-server.providers: Paths to search for Keycloak provider jars.
swarm.keycloak-server.scheduled-task-interval: The interval (in seconds) to run scheduled tasks.
swarm.keycloak-server.spis.KEY.default-provider: The default provider for the spi.
swarm.keycloak-server.spis.KEY.providers.KEY.enabled: Enable or disable the provider.
swarm.keycloak-server.spis.KEY.providers.KEY.properties: The properties for the provider.
swarm.keycloak-server.themes.KEY.attribute-default: The default theme to use if no theme is specified for a realm.
swarm.keycloak-server.themes.KEY.cachetemplates: If true, theme templates are cached.
swarm.keycloak-server.themes.KEY.cachethemes: If true, themes are cached.
swarm.keycloak-server.themes.KEY.dir: Directory where themes can be located.
swarm.keycloak-server.themes.KEY.modules: List of modules containing themes.
swarm.keycloak-server.themes.KEY.staticmaxage: Maximum time the browser should cache theme resources. A value of -1 will disable caching.
swarm.keycloak-server.themes.KEY.welcometheme: The welcome theme.
swarm.keycloak-server.web-context: Web context where Keycloak server is bound. Default value is 'auth'.
thorntail.keycloak-server.combine-default-and-custom-themes: Combine the default themes with the custom themes

6.37. Logging

Provides facilities to configure logging categories, levels and handlers.

When specifying log-levels through properties, since they include dots, they should be placed between square brackets, such as swarm.logging.loggers.[com.mycorp.logger].level.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>logging</artifactId>
</dependency>

Configuration

swarm.logging.add-logging-api-dependencies: Indicates whether or not logging API dependencies should be added to deployments during the deployment process. A value of true will add the dependencies to the deployment. A value of false will skip the deployment from being processed for logging API dependencies.
swarm.logging.async-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.async-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.async-handlers.KEY.level: The log level specifying which message levels will be logged by this handler. Message levels lower than this value will be discarded.
swarm.logging.async-handlers.KEY.name: The name of the handler.
swarm.logging.async-handlers.KEY.overflow-action: Specify what action to take when the overflowing. The valid options are 'block' and 'discard'
swarm.logging.async-handlers.KEY.queue-length: The queue length to use before flushing writing
swarm.logging.async-handlers.KEY.subhandlers: The Handlers associated with this async handler.
swarm.logging.console-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.console-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.console-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.console-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.console-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.console-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.console-handlers.KEY.name: The name of the handler.
swarm.logging.console-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.console-handlers.KEY.target: Defines the target of the console handler. The value can be System.out, System.err or console.
swarm.logging.custom-formatters.KEY.attribute-class: The logging handler class to be used.
swarm.logging.custom-formatters.KEY.module: The module that the logging handler depends on.
swarm.logging.custom-formatters.KEY.properties: Defines the properties used for the logging handler. All properties must be accessible via a setter method.
swarm.logging.custom-handlers.KEY.attribute-class: The logging handler class to be used.
swarm.logging.custom-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.custom-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.custom-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.custom-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.custom-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.custom-handlers.KEY.module: The module that the logging handler depends on.
swarm.logging.custom-handlers.KEY.name: The name of the handler.
swarm.logging.custom-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.custom-handlers.KEY.properties: Defines the properties used for the logging handler. All properties must be accessible via a setter method.
swarm.logging.file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.file-handlers.KEY.name: The name of the handler.
swarm.logging.file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.log-files.KEY.file-size: The size of the log file in bytes.
swarm.logging.log-files.KEY.last-modified-time: The date, in milliseconds, the file was last modified.
swarm.logging.log-files.KEY.last-modified-timestamp: The date, in ISO 8601 format, the file was last modified.
swarm.logging.log-files.KEY.stream: Provides the server log as a response attachment. The response result value is the unique id of the attachment.
swarm.logging.loggers.KEY.category: Specifies the category for the logger.
swarm.logging.loggers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.loggers.KEY.handlers: The handlers associated with the logger.
swarm.logging.loggers.KEY.level: The log level specifying which message levels will be logged by the logger. Message levels lower than this value will be discarded.
swarm.logging.loggers.KEY.use-parent-handlers: Specifies whether or not this logger should send its output to its parent Logger.
swarm.logging.logging-profiles.KEY.async-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.async-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.async-handlers.KEY.level: The log level specifying which message levels will be logged by this handler. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.async-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.async-handlers.KEY.overflow-action: Specify what action to take when the overflowing. The valid options are 'block' and 'discard'
swarm.logging.logging-profiles.KEY.async-handlers.KEY.queue-length: The queue length to use before flushing writing
swarm.logging.logging-profiles.KEY.async-handlers.KEY.subhandlers: The Handlers associated with this async handler.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.console-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.logging-profiles.KEY.console-handlers.KEY.target: Defines the target of the console handler. The value can be System.out, System.err or console.
swarm.logging.logging-profiles.KEY.custom-formatters.KEY.attribute-class: The logging handler class to be used.
swarm.logging.logging-profiles.KEY.custom-formatters.KEY.module: The module that the logging handler depends on.
swarm.logging.logging-profiles.KEY.custom-formatters.KEY.properties: Defines the properties used for the logging handler. All properties must be accessible via a setter method.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.attribute-class: The logging handler class to be used.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.module: The module that the logging handler depends on.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.logging-profiles.KEY.custom-handlers.KEY.properties: Defines the properties used for the logging handler. All properties must be accessible via a setter method.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.logging-profiles.KEY.log-files.KEY.file-size: The size of the log file in bytes.
swarm.logging.logging-profiles.KEY.log-files.KEY.last-modified-time: The date, in milliseconds, the file was last modified.
swarm.logging.logging-profiles.KEY.log-files.KEY.last-modified-timestamp: The date, in ISO 8601 format, the file was last modified.
swarm.logging.logging-profiles.KEY.log-files.KEY.stream: Provides the server log as a response attachment. The response result value is the unique id of the attachment.
swarm.logging.logging-profiles.KEY.loggers.KEY.category: Specifies the category for the logger.
swarm.logging.logging-profiles.KEY.loggers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.loggers.KEY.handlers: The handlers associated with the logger.
swarm.logging.logging-profiles.KEY.loggers.KEY.level: The log level specifying which message levels will be logged by the logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.loggers.KEY.use-parent-handlers: Specifies whether or not this logger should send its output to its parent Logger.
swarm.logging.logging-profiles.KEY.pattern-formatters.KEY.color-map: The color-map attribute allows for a comma delimited list of colors to be used for different levels with a pattern formatter. The format for the color mapping pattern is level-name:color-name.Valid Levels; severe, fatal, error, warn, warning, info, debug, trace, config, fine, finer, finest Valid Colors; black, green, red, yellow, blue, magenta, cyan, white, brightblack, brightred, brightgreen, brightblue, brightyellow, brightmagenta, brightcyan, brightwhite
swarm.logging.logging-profiles.KEY.pattern-formatters.KEY.pattern: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.logging-profiles.KEY.periodic-rotating-file-handlers.KEY.suffix: Set the suffix string. The string is in a format which can be understood by java.text.SimpleDateFormat. The period of the rotation is automatically calculated based on the suffix.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.max-backup-index: The maximum number of backups to keep.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.rotate-on-boot: Indicates the file should be rotated each time the file attribute is changed. This always happens when at initialization time.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.rotate-size: The size at which to rotate the log file.
swarm.logging.logging-profiles.KEY.periodic-size-rotating-file-handlers.KEY.suffix: Set the suffix string. The string is in a format which can be understood by java.text.SimpleDateFormat. The period of the rotation is automatically calculated based on the suffix.
swarm.logging.logging-profiles.KEY.root-logger.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.root-logger.handlers: The handlers associated with the root logger.
swarm.logging.logging-profiles.KEY.root-logger.level: The log level specifying which message levels will be logged by the root logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.max-backup-index: The maximum number of backups to keep.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.name: The name of the handler.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.rotate-on-boot: Indicates the file should be rotated each time the file attribute is changed. This always happens when at initialization time.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.rotate-size: The size at which to rotate the log file.
swarm.logging.logging-profiles.KEY.size-rotating-file-handlers.KEY.suffix: Set the suffix string. The string is in a format which can be understood by java.text.SimpleDateFormat. The suffix does not determine when the file should be rotated.
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.app-name: The app name used when formatting the message in RFC5424 format. By default the app name is "java".
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.facility: Facility as defined by RFC-5424 (http://tools.ietf.org/html/rfc5424)and RFC-3164 (http://tools.ietf.org/html/rfc3164).
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.hostname: The name of the host the messages are being sent from. For example the name of the host the application server is running on.
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.port: The port the syslog server is listening on.
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.server-address: The address of the syslog server.
swarm.logging.logging-profiles.KEY.syslog-handlers.KEY.syslog-format: Formats the log message according to the RFC specification.
swarm.logging.pattern-formatters.KEY.color-map: The color-map attribute allows for a comma delimited list of colors to be used for different levels with a pattern formatter. The format for the color mapping pattern is level-name:color-name.Valid Levels; severe, fatal, error, warn, warning, info, debug, trace, config, fine, finer, finest Valid Colors; black, green, red, yellow, blue, magenta, cyan, white, brightblack, brightred, brightgreen, brightblue, brightyellow, brightmagenta, brightcyan, brightwhite
swarm.logging.pattern-formatters.KEY.pattern: Defines a pattern for the formatter.
swarm.logging.periodic-rotating-file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.periodic-rotating-file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.periodic-rotating-file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.periodic-rotating-file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.periodic-rotating-file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.periodic-rotating-file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.periodic-rotating-file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.periodic-rotating-file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.periodic-rotating-file-handlers.KEY.name: The name of the handler.
swarm.logging.periodic-rotating-file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.periodic-rotating-file-handlers.KEY.suffix: Set the suffix string. The string is in a format which can be understood by java.text.SimpleDateFormat. The period of the rotation is automatically calculated based on the suffix.
swarm.logging.periodic-size-rotating-file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.periodic-size-rotating-file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.periodic-size-rotating-file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.periodic-size-rotating-file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.periodic-size-rotating-file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.periodic-size-rotating-file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.periodic-size-rotating-file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.periodic-size-rotating-file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.periodic-size-rotating-file-handlers.KEY.max-backup-index: The maximum number of backups to keep.
swarm.logging.periodic-size-rotating-file-handlers.KEY.name: The name of the handler.
swarm.logging.periodic-size-rotating-file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.periodic-size-rotating-file-handlers.KEY.rotate-on-boot: Indicates the file should be rotated each time the file attribute is changed. This always happens when at initialization time.
swarm.logging.periodic-size-rotating-file-handlers.KEY.rotate-size: The size at which to rotate the log file.
swarm.logging.periodic-size-rotating-file-handlers.KEY.suffix: Set the suffix string. The string is in a format which can be understood by java.text.SimpleDateFormat. The period of the rotation is automatically calculated based on the suffix.
swarm.logging.root-logger.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.root-logger.handlers: The handlers associated with the root logger.
swarm.logging.root-logger.level: The log level specifying which message levels will be logged by the root logger. Message levels lower than this value will be discarded.
swarm.logging.size-rotating-file-handlers.KEY.append: Specify whether to append to the target file.
swarm.logging.size-rotating-file-handlers.KEY.autoflush: Automatically flush after each write.
swarm.logging.size-rotating-file-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.size-rotating-file-handlers.KEY.encoding: The character encoding used by this Handler.
swarm.logging.size-rotating-file-handlers.KEY.file: The file description consisting of the path and optional relative to path.
swarm.logging.size-rotating-file-handlers.KEY.filter-spec: A filter expression value to define a filter. Example for a filter that does not match a pattern: not(match("JBAS.*"))
swarm.logging.size-rotating-file-handlers.KEY.formatter: Defines a pattern for the formatter.
swarm.logging.size-rotating-file-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.size-rotating-file-handlers.KEY.max-backup-index: The maximum number of backups to keep.
swarm.logging.size-rotating-file-handlers.KEY.name: The name of the handler.
swarm.logging.size-rotating-file-handlers.KEY.named-formatter: The name of the defined formatter to be used on the handler.
swarm.logging.size-rotating-file-handlers.KEY.rotate-on-boot: Indicates the file should be rotated each time the file attribute is changed. This always happens when at initialization time.
swarm.logging.size-rotating-file-handlers.KEY.rotate-size: The size at which to rotate the log file.
swarm.logging.size-rotating-file-handlers.KEY.suffix: Set the suffix string. The string is in a format which can be understood by java.text.SimpleDateFormat. The suffix does not determine when the file should be rotated.
swarm.logging.syslog-handlers.KEY.app-name: The app name used when formatting the message in RFC5424 format. By default the app name is "java".
swarm.logging.syslog-handlers.KEY.enabled: If set to true the handler is enabled and functioning as normal, if set to false the handler is ignored when processing log messages.
swarm.logging.syslog-handlers.KEY.facility: Facility as defined by RFC-5424 (http://tools.ietf.org/html/rfc5424)and RFC-3164 (http://tools.ietf.org/html/rfc3164).
swarm.logging.syslog-handlers.KEY.hostname: The name of the host the messages are being sent from. For example the name of the host the application server is running on.
swarm.logging.syslog-handlers.KEY.level: The log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded.
swarm.logging.syslog-handlers.KEY.port: The port the syslog server is listening on.
swarm.logging.syslog-handlers.KEY.server-address: The address of the syslog server.
swarm.logging.syslog-handlers.KEY.syslog-format: Formats the log message according to the RFC specification.
swarm.logging.use-deployment-logging-config: Indicates whether or not deployments should use a logging configuration file found in the deployment to configure the log manager. If set to true and a logging configuration file was found in the deployments META-INF or WEB-INF/classes directory, then a log manager will be configured with those settings. If set false the servers logging configuration will be used regardless of any logging configuration files supplied in the deployment.

6.38. Logstash

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>logstash</artifactId>
</dependency>

Configuration

thorntail.logstash.enabled: Flag to enable Logstash logging
thorntail.logstash.formatter-properties: Logstash formatter properties
thorntail.logstash.hostname: Host name of the Logstash server
thorntail.logstash.level: Log level
thorntail.logstash.port: Port of the Logstash server

6.39. Mail

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>mail</artifactId>
</dependency>

Configuration

swarm.mail.mail-sessions.KEY.customs.KEY.credential-reference: Credential (from Credential Store) to authenticate on server
swarm.mail.mail-sessions.KEY.customs.KEY.outbound-socket-binding-ref: Outbound Socket binding to mail server
swarm.mail.mail-sessions.KEY.customs.KEY.password: Password to authenticate on server
swarm.mail.mail-sessions.KEY.customs.KEY.properties: JavaMail properties
swarm.mail.mail-sessions.KEY.customs.KEY.ssl: Does server require SSL?
swarm.mail.mail-sessions.KEY.customs.KEY.tls: Does server require TLS?
swarm.mail.mail-sessions.KEY.customs.KEY.username: Username to authenticate on server
swarm.mail.mail-sessions.KEY.debug: Enables JavaMail debugging
swarm.mail.mail-sessions.KEY.from: From address that is used as default from, if not set when sending
swarm.mail.mail-sessions.KEY.imap-server.credential-reference: Credential (from Credential Store) to authenticate on server
swarm.mail.mail-sessions.KEY.imap-server.outbound-socket-binding-ref: Outbound Socket binding to mail server
swarm.mail.mail-sessions.KEY.imap-server.password: Password to authenticate on server
swarm.mail.mail-sessions.KEY.imap-server.ssl: Does server require SSL?
swarm.mail.mail-sessions.KEY.imap-server.tls: Does server require TLS?
swarm.mail.mail-sessions.KEY.imap-server.username: Username to authenticate on server
swarm.mail.mail-sessions.KEY.jndi-name: JNDI name to where mail session should be bound
swarm.mail.mail-sessions.KEY.pop3-server.credential-reference: Credential (from Credential Store) to authenticate on server
swarm.mail.mail-sessions.KEY.pop3-server.outbound-socket-binding-ref: Outbound Socket binding to mail server
swarm.mail.mail-sessions.KEY.pop3-server.password: Password to authenticate on server
swarm.mail.mail-sessions.KEY.pop3-server.ssl: Does server require SSL?
swarm.mail.mail-sessions.KEY.pop3-server.tls: Does server require TLS?
swarm.mail.mail-sessions.KEY.pop3-server.username: Username to authenticate on server
swarm.mail.mail-sessions.KEY.smtp-server.credential-reference: Credential (from Credential Store) to authenticate on server
swarm.mail.mail-sessions.KEY.smtp-server.outbound-socket-binding-ref: Outbound Socket binding to mail server
swarm.mail.mail-sessions.KEY.smtp-server.password: Password to authenticate on server
swarm.mail.mail-sessions.KEY.smtp-server.ssl: Does server require SSL?
swarm.mail.mail-sessions.KEY.smtp-server.tls: Does server require TLS?
swarm.mail.mail-sessions.KEY.smtp-server.username: Username to authenticate on server
thorntail.mail.smtp.host: Host name of the default SMTP server
thorntail.mail.smtp.port: Port of the default SMTP server

6.40. Management

Provides the WildFly management API.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>management</artifactId>
</dependency>

Configuration

thorntail.management.audit-access.audit-log-logger.enabled: Whether audit logging is enabled.
thorntail.management.audit-access.audit-log-logger.log-boot: Whether operations should be logged on server boot.
thorntail.management.audit-access.audit-log-logger.log-read-only: Whether operations that do not modify the configuration or any runtime services should be logged.
thorntail.management.audit-access.file-handlers.KEY.disabled-due-to-failure: Whether this handler has been disabled due to logging failures.
thorntail.management.audit-access.file-handlers.KEY.failure-count: The number of logging failures since the handler was initialized.
thorntail.management.audit-access.file-handlers.KEY.formatter: The formatter used to format the log messages.
thorntail.management.audit-access.file-handlers.KEY.max-failure-count: The maximum number of logging failures before disabling this handler.
thorntail.management.audit-access.file-handlers.KEY.path: The path of the audit log file.
thorntail.management.audit-access.file-handlers.KEY.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.audit-access.file-handlers.KEY.rotate-at-startup: Whether the old log file should be rotated at server startup.
thorntail.management.audit-access.in-memory-handlers.KEY.max-history: The maximum number of operation stored in history for this handler.
thorntail.management.audit-access.json-formatters.KEY.compact: If true will format the JSON on one line. There may still be values containing new lines, so if having the whole record on one line is important, set escape-new-line or escape-control-characters to true.
thorntail.management.audit-access.json-formatters.KEY.date-format: The date format to use as understood by java.text.SimpleDateFormat. Will be ignored if include-date="false".
thorntail.management.audit-access.json-formatters.KEY.date-separator: The separator between the date and the rest of the formatted log message. Will be ignored if include-date="false".
thorntail.management.audit-access.json-formatters.KEY.escape-control-characters: If true will escape all control characters (ascii entries with a decimal value < 32) with the ascii code in octal, e.g.' becomes '#012'. If this is true, it will override escape-new-line="false".
thorntail.management.audit-access.json-formatters.KEY.escape-new-line: If true will escape all new lines with the ascii code in octal, e.g. "#012".
thorntail.management.audit-access.json-formatters.KEY.include-date: Whether or not to include the date in the formatted log record.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.disabled-due-to-failure: Whether this handler has been disabled due to logging failures.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.failure-count: The number of logging failures since the handler was initialized.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.formatter: The formatter used to format the log messages.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.max-failure-count: The maximum number of logging failures before disabling this handler.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.path: The path of the audit log file.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.audit-access.periodic-rotating-file-handlers.KEY.suffix: The suffix string in a format which can be understood by java.text.SimpleDateFormat. The period of the rotation is automatically calculated based on the suffix.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.disabled-due-to-failure: Whether this handler has been disabled due to logging failures.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.failure-count: The number of logging failures since the handler was initialized.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.formatter: The formatter used to format the log messages.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.max-backup-index: The maximum number of backups to keep.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.max-failure-count: The maximum number of logging failures before disabling this handler.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.path: The path of the audit log file.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.audit-access.size-rotating-file-handlers.KEY.rotate-size: The size at which to rotate the log file.
thorntail.management.audit-access.syslog-handlers.KEY.app-name: The application name to add to the syslog records as defined in section 6.2.5 of RFC-5424. If not specified it will default to the name of the product.
thorntail.management.audit-access.syslog-handlers.KEY.disabled-due-to-failure: Whether this handler has been disabled due to logging failures.
thorntail.management.audit-access.syslog-handlers.KEY.facility: The facility to use for syslog logging as defined in section 6.2.1 of RFC-5424, and section 4.1.1 of RFC-3164.
thorntail.management.audit-access.syslog-handlers.KEY.failure-count: The number of logging failures since the handler was initialized.
thorntail.management.audit-access.syslog-handlers.KEY.formatter: The formatter used to format the log messages.
thorntail.management.audit-access.syslog-handlers.KEY.max-failure-count: The maximum number of logging failures before disabling this handler.
thorntail.management.audit-access.syslog-handlers.KEY.max-length: The maximum length in bytes a log message, including the header, is allowed to be. If undefined, it will default to 1024 bytes if the syslog-format is RFC3164, or 2048 bytes if the syslog-format is RFC5424.
thorntail.management.audit-access.syslog-handlers.KEY.syslog-format: Whether to set the syslog format to the one specified in RFC-5424 or RFC-3164.
thorntail.management.audit-access.syslog-handlers.KEY.tcp-protocol.host: The host of the syslog server for the tcp requests.
thorntail.management.audit-access.syslog-handlers.KEY.tcp-protocol.message-transfer: The message transfer setting as described in section 3.4 of RFC-6587. This can either be OCTET_COUNTING as described in section 3.4.1 of RFC-6587, or NON_TRANSPARENT_FRAMING as described in section 3.4.1 of RFC-6587. See your syslog provider’s documentation for what is supported.
thorntail.management.audit-access.syslog-handlers.KEY.tcp-protocol.port: The port of the syslog server for the tcp requests.
thorntail.management.audit-access.syslog-handlers.KEY.tcp-protocol.reconnect-timeout: If a connection drop is detected, the number of seconds to wait before reconnecting. A negative number means don’t reconnect automatically.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.key-password: The password for the keystore key.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.key-password-credential-reference: The reference to credential for the keystore key stored in CredentialStore under defined alias or clear text password.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.keystore-password: The password for the keystore.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.keystore-password-credential-reference: The reference to credential for the keystore password stored in CredentialStore under defined alias or clear text password.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.keystore-path: The path of the keystore.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.keystore-relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'keystore-relative-to' is provided, the value of the 'keystore-path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.host: The host of the syslog server for the tls over tcp requests.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.message-transfer: The message transfer setting as described in section 3.4 of RFC-6587. This can either be OCTET_COUNTING as described in section 3.4.1 of RFC-6587, or NON_TRANSPARENT_FRAMING as described in section 3.4.1 of RFC-6587. See your syslog provider’s documentation for what is supported.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.port: The port of the syslog server for the tls over tcp requests.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.reconnect-timeout: If a connection drop is detected, the number of seconds to wait before reconnecting. A negative number means don’t reconnect automatically.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.truststore-authentication.keystore-password: The password for the truststore.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.truststore-authentication.keystore-password-credential-reference: The reference to credential for the truststore password stored in CredentialStore under defined alias or clear text password.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.truststore-authentication.keystore-path: The path of the truststore.
thorntail.management.audit-access.syslog-handlers.KEY.tls-protocol.truststore-authentication.keystore-relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'keystore-relative-to' is provided, the value of the 'keystore-path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.audit-access.syslog-handlers.KEY.truncate: Whether or not a message, including the header, should truncate the message if the length in bytes is greater than the maximum length. If set to false messages will be split and sent with the same header values.
thorntail.management.audit-access.syslog-handlers.KEY.udp-protocol.host: The host of the syslog server for the udp requests.
thorntail.management.audit-access.syslog-handlers.KEY.udp-protocol.port: The port of the syslog server for the udp requests.
thorntail.management.authorization-access.all-role-names: The official names of all roles supported by the current management access control provider. This includes any standard roles as well as any user-defined roles.
thorntail.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.address: Address pattern describing a resource or resources to which the constraint applies.
thorntail.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.attributes: List of the names of attributes to which the constraint specifically applies.
thorntail.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.entire-resource: True if the constraint applies to the resource as a whole; false if it only applies to one or more attributes or operations.
thorntail.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.operations: List of the names of operations to which the constraint specifically applies.
thorntail.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.configured-application: Set to override the default as to whether the constraint is considered an application resource.
thorntail.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.default-application: Whether targets having this application type constraint are considered application resources.
thorntail.management.authorization-access.permission-combination-policy: The policy for combining access control permissions when the authorization policy grants the user more than one type of permission for a given action. In the standard role based authorization policy, this would occur when a user maps to multiple roles. The 'permissive' policy means if any of the permissions allow the action, the action is allowed. The 'rejecting' policy means the existence of multiple permissions should result in an error.
thorntail.management.authorization-access.provider: The provider to use for management access control decisions.
thorntail.management.authorization-access.role-mappings.KEY.excludes.KEY.name: The name of the user or group being mapped.
thorntail.management.authorization-access.role-mappings.KEY.excludes.KEY.realm: An optional attribute to map based on the realm used for authentication.
thorntail.management.authorization-access.role-mappings.KEY.excludes.KEY.type: The type of the Principal being mapped, either 'group' or 'user'.
thorntail.management.authorization-access.role-mappings.KEY.include-all: Configure if all authenticated users should be automatically assigned this role.
thorntail.management.authorization-access.role-mappings.KEY.includes.KEY.name: The name of the user or group being mapped.
thorntail.management.authorization-access.role-mappings.KEY.includes.KEY.realm: An optional attribute to map based on the realm used for authentication.
thorntail.management.authorization-access.role-mappings.KEY.includes.KEY.type: The type of the Principal being mapped, either 'group' or 'user'.
thorntail.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.address: Address pattern describing a resource or resources to which the constraint applies.
thorntail.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.attributes: List of the names of attributes to which the constraint specifically applies.
thorntail.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.entire-resource: True if the constraint applies to the resource as a whole; false if it only applies to one or more attributes or operations.
thorntail.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.applies-tos.KEY.operations: List of the names of operations to which the constraint specifically applies.
thorntail.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.configured-application: Set to override the default as to whether the constraint is considered an application resource.
thorntail.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.default-application: Whether targets having this application type constraint are considered application resources.
thorntail.management.authorization-access.standard-role-names: The official names of the standard roles supported by the current management access control provider.
thorntail.management.authorization-access.use-identity-roles: Should the raw roles obtained from the underlying security identity be used directly?
thorntail.management.authorization-access.vault-expression-constraint.configured-requires-read: Set to override the default as to whether reading attributes containing vault expressions should be considered sensitive.
thorntail.management.authorization-access.vault-expression-constraint.configured-requires-write: Set to override the default as to whether writing attributes containing vault expressions should be considered sensitive.
thorntail.management.authorization-access.vault-expression-constraint.default-requires-read: Whether reading attributes containing vault expressions should be considered sensitive.
thorntail.management.authorization-access.vault-expression-constraint.default-requires-write: Whether writing attributes containing vault expressions should be considered sensitive.
thorntail.management.bind.interface: Interface to bind for the management ports
thorntail.management.configuration-changes-service.max-history: The maximum number of configuration changes stored in history.
thorntail.management.http-interface-management-interface.allowed-origins: Comma separated list of trusted Origins for sending Cross-Origin Resource Sharing requests on the management API once the user is authenticated.
thorntail.management.http-interface-management-interface.console-enabled: Flag that indicates admin console is enabled
thorntail.management.http-interface-management-interface.http-authentication-factory: The authentication policy to use to secure the interface for normal HTTP requests.
thorntail.management.http-interface-management-interface.http-upgrade: HTTP Upgrade specific configuration
thorntail.management.http-interface-management-interface.http-upgrade-enabled: Flag that indicates HTTP Upgrade is enabled, which allows HTTP requests to be upgraded to native remoting connections
thorntail.management.http-interface-management-interface.sasl-protocol: The name of the protocol to be passed to the SASL mechanisms used for authentication.
thorntail.management.http-interface-management-interface.secure-socket-binding: The name of the socket binding configuration to use for the HTTPS management interface’s socket. When defined at least one of ssl-context or security-realm must also be defined.
thorntail.management.http-interface-management-interface.security-realm: The legacy security realm to use for the HTTP management interface.
thorntail.management.http-interface-management-interface.server-name: The name of the server used in the initial Remoting exchange and within the SASL mechanisms.
thorntail.management.http-interface-management-interface.socket-binding: The name of the socket binding configuration to use for the HTTP management interface’s socket.
thorntail.management.http-interface-management-interface.ssl-context: Reference to the SSLContext to use for this management interface.
thorntail.management.http.disable: Flag to disable HTTP access to management interface
thorntail.management.http.port: Port for HTTP access to management interface
thorntail.management.https.port: Port for HTTPS access to management interface
thorntail.management.identity-access.security-domain: Reference to the security domain to use to obtain the current identity performing a management request.
thorntail.management.ldap-connections.KEY.always-send-client-cert: If true, the client SSL certificate will be sent to LDAP server with every request; otherwise the client SSL certificate will not be sent when verifying the user credentials
thorntail.management.ldap-connections.KEY.handles-referrals-for: List of URLs that this connection handles referrals for.
thorntail.management.ldap-connections.KEY.initial-context-factory: The initial context factory to establish the LdapContext.
thorntail.management.ldap-connections.KEY.properties.KEY.value: The optional value of the property.
thorntail.management.ldap-connections.KEY.referrals: The referral handling mode for this connection.
thorntail.management.ldap-connections.KEY.search-credential: The credential to use when connecting to perform a search.
thorntail.management.ldap-connections.KEY.search-credential-reference: The reference to the search credential stored in CredentialStore under defined alias or clear text password.
thorntail.management.ldap-connections.KEY.search-dn: The distinguished name to use when connecting to the LDAP server to perform searches.
thorntail.management.ldap-connections.KEY.security-realm: The security realm to reference to obtain a configured SSLContext to use when establishing the connection.
thorntail.management.ldap-connections.KEY.url: The URL to use to connect to the LDAP server.
thorntail.management.management-operations-service.active-operations.KEY.access-mechanism: The mechanism used to submit a request to the server.
thorntail.management.management-operations-service.active-operations.KEY.address: The address of the resource targeted by the operation. The value in the final element of the address will be '<hidden>' if the caller is not authorized to address the operation’s target resource.
thorntail.management.management-operations-service.active-operations.KEY.caller-thread: The name of the thread that is executing the operation.
thorntail.management.management-operations-service.active-operations.KEY.cancelled: Whether the operation has been cancelled.
thorntail.management.management-operations-service.active-operations.KEY.domain-rollout: True if the operation is a subsidiary request on a domain process other than the one directly handling the original operation, executing locally as part of the rollout of the original operation across the domain.
thorntail.management.management-operations-service.active-operations.KEY.domain-uuid: Identifier of an overall multi-process domain operation of which this operation is a part, or undefined if this operation is not associated with such a domain operation.
thorntail.management.management-operations-service.active-operations.KEY.exclusive-running-time: Amount of time the operation has been executing with the exclusive operation execution lock held, or -1 if the operation does not hold the exclusive execution lock.
thorntail.management.management-operations-service.active-operations.KEY.execution-status: The current activity of the operation.
thorntail.management.management-operations-service.active-operations.KEY.operation: The name of the operation, or '<hidden>' if the caller is not authorized to address the operation’s target resource.
thorntail.management.management-operations-service.active-operations.KEY.running-time: Amount of time the operation has been executing.
thorntail.management.native-interface-management-interface.sasl-authentication-factory: The SASL authentication policy to use to secure this interface.
thorntail.management.native-interface-management-interface.sasl-protocol: The name of the protocol to be passed to the SASL mechanisms used for authentication.
thorntail.management.native-interface-management-interface.security-realm: The legacy security realm to use for the native management interface.
thorntail.management.native-interface-management-interface.server-name: The name of the server used in the initial Remoting exchange and within the SASL mechanisms.
thorntail.management.native-interface-management-interface.socket-binding: The name of the socket binding configuration to use for the native management interface’s socket.
thorntail.management.native-interface-management-interface.ssl-context: Reference to the SSLContext to use for this management interface.
thorntail.management.security-realms.KEY.jaas-authentication.assign-groups: Map the roles loaded by JAAS to groups.
thorntail.management.security-realms.KEY.jaas-authentication.name: The name of the JAAS configuration to use.
thorntail.management.security-realms.KEY.kerberos-authentication.remove-realm: After authentication should the realm name be stripped from the users name.
thorntail.management.security-realms.KEY.kerberos-server-identity.keytabs.KEY.debug: Should additional debug logging be enabled during TGT acquisition?
thorntail.management.security-realms.KEY.kerberos-server-identity.keytabs.KEY.for-hosts: A server can be accessed using different host names, this attribute specifies which host names this keytab can be used with.
thorntail.management.security-realms.KEY.kerberos-server-identity.keytabs.KEY.path: The path to the keytab.
thorntail.management.security-realms.KEY.kerberos-server-identity.keytabs.KEY.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.security-realms.KEY.ldap-authentication.advanced-filter: The fully defined filter to be used to search for the user based on their entered user ID. The filter should contain a variable in the form {0} - this will be replaced with the username supplied by the user.
thorntail.management.security-realms.KEY.ldap-authentication.allow-empty-passwords: Should empty passwords be accepted from the user being authenticated.
thorntail.management.security-realms.KEY.ldap-authentication.base-dn: The base distinguished name to commence the search for the user.
thorntail.management.security-realms.KEY.ldap-authentication.by-access-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authentication.by-access-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authentication.by-access-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authentication.by-access-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authentication.by-search-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authentication.by-search-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authentication.by-search-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authentication.by-search-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authentication.connection: The name of the connection to use to connect to LDAP.
thorntail.management.security-realms.KEY.ldap-authentication.recursive: Whether the search should be recursive.
thorntail.management.security-realms.KEY.ldap-authentication.user-dn: The name of the attribute which is the user’s distinguished name.
thorntail.management.security-realms.KEY.ldap-authentication.username-attribute: The name of the attribute to search for the user. This filter will then perform a simple search where the username entered by the user matches the attribute specified here.
thorntail.management.security-realms.KEY.ldap-authentication.username-load: The name of the attribute that should be loaded from the authenticated users LDAP entry to replace the username that they supplied, e.g. convert an e-mail address to an ID or correct the case entered.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.base-dn: The starting point of the search for the user.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-access-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-access-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-access-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-access-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-search-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-search-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-search-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-search-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.filter: The filter to use for the LDAP search.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.force: Authentication may have already converted the username to a distinguished name, force this to occur again before loading groups.
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.recursive: Should levels below the starting point be recursively searched?
thorntail.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.user-dn-attribute: The attribute on the user entry that contains their distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.connection: The name of the connection to use to connect to LDAP.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.base-dn: The starting point of the search for the group.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-access-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-access-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-access-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-access-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-search-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-search-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-search-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-search-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.group-dn-attribute: Which attribute on a group entry is it’s distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.group-name: An enumeration to identify if groups should be referenced using a simple name or their distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.group-name-attribute: Which attribute on a group entry is it’s simple name.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.iterative: Should further searches be performed to identify groups that the groups identified are a member of?
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.prefer-original-connection: After following a referral should subsequent searches prefer the original connection or use the connection of the last referral.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.principal-attribute: The attribute on the group entry that references the principal.
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.recursive: Should levels below the starting point be recursively searched?
thorntail.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.search-by: Should searches be performed using simple names or distinguished names?
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-access-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-access-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-access-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-access-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-search-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-search-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-search-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-search-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.group-attribute: The attribute on the principal which references the group the principal is a member of.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.group-dn-attribute: Which attribute on a group entry is it’s distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.group-name: An enumeration to identify if groups should be referenced using a simple name or their distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.group-name-attribute: Which attribute on a group entry is it’s simple name.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.iterative: Should further searches be performed to identify groups that the groups identified are a member of?
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.parse-group-name-from-dn: Should the group name be extracted from the distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.prefer-original-connection: After following a referral should subsequent searches prefer the original connection or use the connection of the last referral.
thorntail.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.skip-missing-groups: If a non-existent group is referenced should it be quietly ignored.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.attribute: The attribute on the user entry that is their username.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.base-dn: The starting point of the search for the user.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-access-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-access-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-access-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-access-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-search-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-search-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-search-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-search-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.force: Authentication may have already converted the username to a distinguished name, force this to occur again before loading groups.
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.recursive: Should levels below the starting point be recursively searched?
thorntail.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.user-dn-attribute: The attribute on the user entry that contains their distinguished name.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-access-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-access-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-access-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-access-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-search-time-cache.cache-failures: Should failures be cached?
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-search-time-cache.cache-size: The current size of the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-search-time-cache.eviction-time: The time in seconds until an entry should be evicted from the cache.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-search-time-cache.max-cache-size: The maximum size of the cache before the oldest items are removed to make room for new entries.
thorntail.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.force: Authentication may have already converted the username to a distinguished name, force this to occur again before loading groups.
thorntail.management.security-realms.KEY.local-authentication.allowed-users: The comma separated list of users that will be accepted using the JBOSS-LOCAL-USER mechanism or '*' to accept all. If specified the default-user is always assumed allowed.
thorntail.management.security-realms.KEY.local-authentication.default-user: The name of the default user to assume if no user specified by the remote client.
thorntail.management.security-realms.KEY.local-authentication.skip-group-loading: Disable the loading of the users group membership information after local authentication has been used.
thorntail.management.security-realms.KEY.map-groups-to-roles: After a users group membership has been loaded should a 1:1 relationship be assumed regarding group to role mapping.
thorntail.management.security-realms.KEY.plug-in-authentication.mechanism: Allow the mechanism this plug-in is compatible with to be overridden from DIGEST.
thorntail.management.security-realms.KEY.plug-in-authentication.name: The short name of the plug-in (as registered) to use.
thorntail.management.security-realms.KEY.plug-in-authentication.properties.KEY.value: The optional value of the property.
thorntail.management.security-realms.KEY.plug-in-authorization.name: The short name of the plug-in (as registered) to use.
thorntail.management.security-realms.KEY.plug-in-authorization.properties.KEY.value: The optional value of the property.
thorntail.management.security-realms.KEY.properties-authentication.path: The path of the properties file containing the users.
thorntail.management.security-realms.KEY.properties-authentication.plain-text: Are the credentials within the properties file stored in plain text. If not the credential is expected to be the hex encoded Digest hash of 'username : realm : password'.
thorntail.management.security-realms.KEY.properties-authentication.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.security-realms.KEY.properties-authorization.path: The path of the properties file containing the users roles.
thorntail.management.security-realms.KEY.properties-authorization.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.security-realms.KEY.secret-server-identity.credential-reference: The reference to credential for the secret / password stored in CredentialStore under defined alias or clear text password.
thorntail.management.security-realms.KEY.secret-server-identity.value: The secret / password - Base64 Encoded.
thorntail.management.security-realms.KEY.ssl-server-identity.alias: The alias of the entry to use from the keystore.
thorntail.management.security-realms.KEY.ssl-server-identity.enabled-cipher-suites: The cipher suites that can be enabled on the underlying SSLEngine.
thorntail.management.security-realms.KEY.ssl-server-identity.enabled-protocols: The protocols that can be enabled on the underlying SSLEngine.
thorntail.management.security-realms.KEY.ssl-server-identity.generate-self-signed-certificate-host: If the keystore does not exist and this attribute is set then a self signed certificate will be generated for the specified host name. This is not intended for production use.
thorntail.management.security-realms.KEY.ssl-server-identity.key-password: The password to obtain the key from the keystore.
thorntail.management.security-realms.KEY.ssl-server-identity.key-password-credential-reference: The reference to credential for the keystore key stored in CredentialStore under defined alias or clear text password.
thorntail.management.security-realms.KEY.ssl-server-identity.keystore-password: The password to open the keystore.
thorntail.management.security-realms.KEY.ssl-server-identity.keystore-password-credential-reference: The reference to credential for the keystore password stored in CredentialStore under defined alias or clear text password.
thorntail.management.security-realms.KEY.ssl-server-identity.keystore-path: The path of the keystore, will be ignored if the keystore-provider is anything other than JKS.
thorntail.management.security-realms.KEY.ssl-server-identity.keystore-provider: The provider for loading the keystore, defaults to JKS.
thorntail.management.security-realms.KEY.ssl-server-identity.keystore-relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.security-realms.KEY.ssl-server-identity.protocol: The protocol to use when creating the SSLContext.
thorntail.management.security-realms.KEY.truststore-authentication.keystore-password: The password to open the keystore.
thorntail.management.security-realms.KEY.truststore-authentication.keystore-password-credential-reference: The reference to credential for the keystore password stored in CredentialStore under defined alias or clear text password.
thorntail.management.security-realms.KEY.truststore-authentication.keystore-path: The path of the keystore, will be ignored if the keystore-provider is anything other than JKS.
thorntail.management.security-realms.KEY.truststore-authentication.keystore-provider: The provider for loading the keystore, defaults to JKS.
thorntail.management.security-realms.KEY.truststore-authentication.keystore-relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.
thorntail.management.security-realms.KEY.users-authentication.users.KEY.credential-reference: The reference to credential for the password stored in CredentialStore under defined alias or clear text password.
thorntail.management.security-realms.KEY.users-authentication.users.KEY.password: The user’s password.

6.40.1. Management Console

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>management-console</artifactId>
</dependency>

Configuration

thorntail.management-console.context: Web context path of the management console

6.41. Messaging

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>messaging</artifactId>
</dependency>

Configuration

thorntail.messaging-activemq.global-client-scheduled-thread-pool-max-size: Maximum size of the pool of threads used by all ActiveMQ clients running inside this server. If the attribute is undefined (by default), ActiveMQ will configure it to be 8 x the number of available processors.
thorntail.messaging-activemq.global-client-thread-pool-max-size: Maximum size of the pool of scheduled threads used by all ActiveMQ clients running inside this server.
thorntail.messaging-activemq.jms-bridges.KEY.add-messageid-in-header: If true, then the original message’s message ID will be appended in the message sent to the destination in the header AMQ_BRIDGE_MSG_ID_LIST. If the message is bridged more than once, each message ID will be appended.
thorntail.messaging-activemq.jms-bridges.KEY.client-id: The JMS client ID to use when creating/looking up the subscription if it is durable and the source destination is a topic.
thorntail.messaging-activemq.jms-bridges.KEY.failure-retry-interval: The amount of time in milliseconds to wait between trying to recreate connections to the source or target servers when the bridge has detected they have failed.
thorntail.messaging-activemq.jms-bridges.KEY.max-batch-size: The maximum number of messages to consume from the source destination before sending them in a batch to the target destination. Its value must >= 1.
thorntail.messaging-activemq.jms-bridges.KEY.max-batch-time: The maximum number of milliseconds to wait before sending a batch to target, even if the number of messages consumed has not reached max-batch-size. Its value must be -1 to represent 'wait forever', or >= 1 to specify an actual time.
thorntail.messaging-activemq.jms-bridges.KEY.max-retries: The number of times to attempt to recreate connections to the source or target servers when the bridge has detected they have failed. The bridge will give up after trying this number of times. -1 represents 'try forever'.
thorntail.messaging-activemq.jms-bridges.KEY.module: The name of AS7 module containing the resources required to lookup source and target JMS resources.
thorntail.messaging-activemq.jms-bridges.KEY.paused: Whether the JMS bridge is paused.
thorntail.messaging-activemq.jms-bridges.KEY.quality-of-service: The desired quality of service mode (AT_MOST_ONCE, DUPLICATES_OK or ONCE_AND_ONLY_ONCE).
thorntail.messaging-activemq.jms-bridges.KEY.selector: A JMS selector expression used for consuming messages from the source destination. Only messages that match the selector expression will be bridged from the source to the target destination.
thorntail.messaging-activemq.jms-bridges.KEY.source-connection-factory: The name of the source connection factory to lookup on the source messaging server.
thorntail.messaging-activemq.jms-bridges.KEY.source-context: The properties used to configure the source JNDI initial context.
thorntail.messaging-activemq.jms-bridges.KEY.source-credential-reference: Credential (from Credential Store) to authenticate source connection
thorntail.messaging-activemq.jms-bridges.KEY.source-destination: The name of the source destination to lookup on the source messaging server.
thorntail.messaging-activemq.jms-bridges.KEY.source-password: The password for creating the source connection.
thorntail.messaging-activemq.jms-bridges.KEY.source-user: The name of the user for creating the source connection.
thorntail.messaging-activemq.jms-bridges.KEY.started: Whether the JMS bridge is started.
thorntail.messaging-activemq.jms-bridges.KEY.subscription-name: The name of the subscription if it is durable and the source destination is a topic.
thorntail.messaging-activemq.jms-bridges.KEY.target-connection-factory: The name of the target connection factory to lookup on the target messaging server.
thorntail.messaging-activemq.jms-bridges.KEY.target-context: The properties used to configure the target JNDI initial context.
thorntail.messaging-activemq.jms-bridges.KEY.target-credential-reference: Credential (from Credential Store) to authenticate target connection
thorntail.messaging-activemq.jms-bridges.KEY.target-destination: The name of the target destination to lookup on the target messaging server.
thorntail.messaging-activemq.jms-bridges.KEY.target-password: The password for creating the target connection.
thorntail.messaging-activemq.jms-bridges.KEY.target-user: The name of the user for creating the target connection.
thorntail.messaging-activemq.servers.KEY.acceptors.KEY.factory-class: Class name of the factory class that can instantiate the acceptor.
thorntail.messaging-activemq.servers.KEY.acceptors.KEY.params: A key-value pair understood by the acceptor factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.acceptors.KEY.socket-binding: The socket binding that the acceptor will use to accept connections.
thorntail.messaging-activemq.servers.KEY.acceptors.KEY.started: Whether this acceptor is started.
thorntail.messaging-activemq.servers.KEY.active: Whether the server is active (and accepting connections) or passive (in backup mode, waiting for failover).
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.address-full-policy: Determines what happens when an address where max-size-bytes is specified becomes full. (PAGE, DROP or BLOCK)
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.auto-create-jms-queues: Determines whether ActiveMQ should automatically create a JMS queue corresponding to the address-settings match when a JMS producer or a consumer is tries to use such a queue.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.auto-delete-jms-queues: Determises Whether ActiveMQ should automatically delete auto-created JMS queues when they have no consumers and no messages.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.dead-letter-address: The dead letter address
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.expiry-address: Defines where to send a message that has expired.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.expiry-delay: Defines the expiration time that will be used for messages using the default expiration time
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.last-value-queue: Defines whether a queue only uses last values or not
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.max-delivery-attempts: Defines how many time a cancelled message can be redelivered before sending to the dead-letter-address
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.max-redelivery-delay: Maximum value for the redelivery-delay (in ms).
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.max-size-bytes: The max bytes size.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.message-counter-history-day-limit: Day limit for the message counter history.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.page-max-cache-size: The number of page files to keep in memory to optimize IO during paging navigation.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.page-size-bytes: The paging size.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.redelivery-delay: Defines how long to wait before attempting redelivery of a cancelled message
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.redelivery-multiplier: Multiplier to apply to the redelivery-delay parameter
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.redistribution-delay: Defines how long to wait when the last consumer is closed on a queue before redistributing any messages
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.send-to-dla-on-no-route: If this parameter is set to true for that address, if the message is not routed to any queues it will instead be sent to the dead letter address (DLA) for that address, if it exists.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.slow-consumer-check-period: How often to check for slow consumers on a particular queue.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.slow-consumer-policy: Determine what happens when a slow consumer is identified.
thorntail.messaging-activemq.servers.KEY.address-settings.KEY.slow-consumer-threshold: The minimum rate of message consumption allowed before a consumer is considered slow.
thorntail.messaging-activemq.servers.KEY.async-connection-execution-enabled: Whether incoming packets on the server should be handed off to a thread from the thread pool for processing. False if they should be handled on the remoting thread.
thorntail.messaging-activemq.servers.KEY.bindings-directory-path.path: The actual filesystem path. Treated as an absolute path, unless the 'relative-to' attribute is specified, in which case the value is treated as relative to that path. If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: If this value is already absolute, then the value is directly used. Otherwise the runtime pathname is resolved in a system-dependent way. On UNIX systems, a relative pathname is made absolute by resolving it against the current user directory. On Microsoft Windows systems, a relative pathname is made absolute by resolving it against the current directory of the drive named by the pathname, if any; if not, it is resolved against the current user directory.
thorntail.messaging-activemq.servers.KEY.bindings-directory-path.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute. The standard paths provided by the system include: jboss.home - the root directory of the JBoss AS distribution, user.home - user’s home directory, user.dir - user’s current working directory, java.home - java installation directory, jboss.server.base.dir - root directory for an individual server instance, jboss.server.data.dir - directory the server will use for persistent data file storage, jboss.server.log.dir - directory the server will use for log file storage, jboss.server.tmp.dir - directory the server will use for temporary file storage, and jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.check-period: The period (in milliseconds) between client failure check.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.confirmation-window-size: The confirmation-window-size to use for the connection used to forward messages to the target node.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.connection-ttl: The maximum time (in milliseconds) for which the connections used by the bridges are considered alive (in the absence of heartbeat).
thorntail.messaging-activemq.servers.KEY.bridges.KEY.credential-reference: Credential (from Credential Store) to authenticate the bridge
thorntail.messaging-activemq.servers.KEY.bridges.KEY.discovery-group: The name of the discovery group used by this bridge. Must be undefined (null) if 'static-connectors' is defined.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.filter: An optional filter string. If specified then only messages which match the filter expression specified will be forwarded. The filter string follows the ActiveMQ filter expression syntax described in the ActiveMQ documentation.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.forwarding-address: The address on the target server that the message will be forwarded to. If a forwarding address is not specified then the original destination of the message will be retained.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.ha: Whether or not this bridge should support high availability. True means it will connect to any available server in a cluster and support failover.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.initial-connect-attempts: The number of attempts to connect initially with this bridge.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.max-retry-interval: The maximum interval of time used to retry connections
thorntail.messaging-activemq.servers.KEY.bridges.KEY.min-large-message-size: The minimum size (in bytes) for a message before it is considered as a large message.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.password: The password to use when creating the bridge connection to the remote server. If it is not specified the default cluster password specified by the cluster-password attribute in the root messaging subsystem resource will be used.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.producer-window-size: Producer flow control size on the bridge.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.queue-name: The unique name of the local queue that the bridge consumes from.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.reconnect-attempts: The total number of reconnect attempts the bridge will make before giving up and shutting down. A value of -1 signifies an unlimited number of attempts.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.reconnect-attempts-on-same-node: The total number of reconnect attempts on the same node the bridge will make before giving up and shutting down. A value of -1 signifies an unlimited number of attempts.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.retry-interval: The period in milliseconds between subsequent reconnection attempts, if the connection to the target server has failed.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.retry-interval-multiplier: A multiplier to apply to the time since the last retry to compute the time to the next retry. This allows you to implement an exponential backoff between retry attempts.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.started: Whether the bridge is started.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.static-connectors: A list of names of statically defined connectors used by this bridge. Must be undefined (null) if 'discovery-group-name' is defined.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.transformer-class-name: The name of a user-defined class which implements the org.apache.activemq.artemis.core.server.cluster.Transformer interface.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.use-duplicate-detection: Whether the bridge will automatically insert a duplicate id property into each message that it forwards.
thorntail.messaging-activemq.servers.KEY.bridges.KEY.user: The user name to use when creating the bridge connection to the remote server. If it is not specified the default cluster user specified by the cluster-user attribute in the root messaging subsystem resource will be used.
thorntail.messaging-activemq.servers.KEY.broadcast-groups.KEY.broadcast-period: The period in milliseconds between consecutive broadcasts.
thorntail.messaging-activemq.servers.KEY.broadcast-groups.KEY.connectors: Specifies the names of connectors that will be broadcast.
thorntail.messaging-activemq.servers.KEY.broadcast-groups.KEY.jgroups-channel: The name used by a JGroups channel to join a cluster.
thorntail.messaging-activemq.servers.KEY.broadcast-groups.KEY.jgroups-stack: The name of a stack defined in the org.jboss.as.clustering.jgroups subsystem that is used to form a cluster.
thorntail.messaging-activemq.servers.KEY.broadcast-groups.KEY.socket-binding: The broadcast group socket binding.
thorntail.messaging-activemq.servers.KEY.broadcast-groups.KEY.started: Whether the broadcast group is started.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.allow-direct-connections-only: Whether, if a node learns of the existence of a node that is more than 1 hop away, we do not create a bridge for direct cluster connection. Only relevant if 'static-connectors' is defined.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.call-failover-timeout: The timeout to use when fail over is in process (in ms) for remote calls made by the cluster connection.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.call-timeout: The timeout (in ms) for remote calls made by the cluster connection.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.check-period: The period (in milliseconds) between client failure check.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.cluster-connection-address: Each cluster connection only applies to messages sent to an address that starts with this value.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.confirmation-window-size: The confirmation-window-size to use for the connection used to forward messages to a target node.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.connection-ttl: The maximum time (in milliseconds) for which the connections used by the cluster connections are considered alive (in the absence of heartbeat).
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.connector-name: The name of connector to use for live connection
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.discovery-group: The discovery group used to obtain the list of other servers in the cluster to which this cluster connection will make connections. Must be undefined (null) if 'static-connectors' is defined.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.initial-connect-attempts: The number of attempts to connect initially with this cluster connection.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.max-hops: The maximum number of times a message can be forwarded. ActiveMQ can be configured to also load balance messages to nodes which might be connected to it only indirectly with other ActiveMQ servers as intermediates in a chain.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.max-retry-interval: The maximum interval of time used to retry connections
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.message-load-balancing-type: The type of message load balancing provided by the cluster connection.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.min-large-message-size: The minimum size (in bytes) for a message before it is considered as a large message.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.node-id: The node ID used by this cluster connection.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.notification-attempts: How many times the cluster connection will broadcast itself
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.notification-interval: How often the cluster connection will broadcast itself
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.producer-window-size: Producer flow control size on the cluster connection.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.reconnect-attempts: The total number of reconnect attempts the bridge will make before giving up and shutting down. A value of -1 signifies an unlimited number of attempts.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.retry-interval: The period in milliseconds between subsequent attempts to reconnect to a target server, if the connection to the target server has failed.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.retry-interval-multiplier: A multiplier to apply to the time since the last retry to compute the time to the next retry. This allows you to implement an exponential backoff between retry attempts.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.started: Whether the cluster connection is started.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.static-connectors: The statically defined list of connectors to which this cluster connection will make connections. Must be undefined (null) if 'discovery-group-name' is defined.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.topology: The topology of the nodes that this cluster connection is aware of.
thorntail.messaging-activemq.servers.KEY.cluster-connections.KEY.use-duplicate-detection: Whether the bridge will automatically insert a duplicate id property into each message that it forwards.
thorntail.messaging-activemq.servers.KEY.cluster-credential-reference: Credential (from Credential Store) to authenticate to cluster
thorntail.messaging-activemq.servers.KEY.cluster-password: The password used by cluster connections to communicate between the clustered nodes.
thorntail.messaging-activemq.servers.KEY.cluster-user: The user used by cluster connections to communicate between the clustered nodes.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.auto-group: Whether or not message grouping is automatically used
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.block-on-acknowledge: True to set block on acknowledge.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.block-on-durable-send: True to set block on durable send.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.block-on-non-durable-send: True to set block on non durable send.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.cache-large-message-client: True to cache large messages.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.call-failover-timeout: The timeout to use when fail over is in process (in ms).
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.call-timeout: The call time out.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.client-failure-check-period: The client failure check period.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.client-id: The client id.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.compress-large-messages: Whether large messages should be compressed.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.confirmation-window-size: The confirmation window size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.connection-load-balancing-policy-class-name: Name of a class implementing a client-side load balancing policy that a client can use to load balance sessions across different nodes in a cluster.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.connection-ttl: The connection ttl.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.connectors: Defines the connectors. These are stored in a map by connector name (with an undefined value). It is possible to pass a list of connector names when writing this attribute.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.consumer-max-rate: The consumer max rate.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.consumer-window-size: The consumer window size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.deserialization-black-list: A list of class names (separated by whitespaces) that are black-listed to be used in serialization of JMS ObjectMessage.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.deserialization-white-list: A list of class names (separated by whitespaces) that are white-listed to be used in serialization of JMS ObjectMessage.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.discovery-group: The discovery group name.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.dups-ok-batch-size: The dups ok batch size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.entries: The jndi names the connection factory should be bound to.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.factory-type: The type of connection factory.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.failover-on-initial-connection: True to fail over on initial connection.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.group-id: The group id.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.ha: Whether the connection factory supports High Availability.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.initial-message-packet-size: The initial size of messages created through this factory.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.max-retry-interval: The max retry interval.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.min-large-message-size: The min large message size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.pre-acknowledge: True to pre-acknowledge.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.producer-max-rate: The producer max rate.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.producer-window-size: The producer window size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.protocol-manager-factory: The protocol manager factory used by this connection factory (it must implement org.apache.activemq.artemis.spi.core.remoting.ClientProtocolManagerFactory).
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.reconnect-attempts: The reconnect attempts.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.retry-interval: The retry interval.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.retry-interval-multiplier: The retry interval multiplier.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.scheduled-thread-pool-max-size: The scheduled thread pool max size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.thread-pool-max-size: The thread pool max size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.transaction-batch-size: The transaction batch size.
thorntail.messaging-activemq.servers.KEY.connection-factories.KEY.use-global-pools: True to use global pools.
thorntail.messaging-activemq.servers.KEY.connection-ttl-override: If set, this will override how long (in ms) to keep a connection alive without receiving a ping.
thorntail.messaging-activemq.servers.KEY.connector-services.KEY.factory-class: Class name of the factory class that can instantiate the connector service.
thorntail.messaging-activemq.servers.KEY.connector-services.KEY.params: A key/value pair understood by the connector service’s factory-class
thorntail.messaging-activemq.servers.KEY.connectors.KEY.factory-class: Class name of the factory class that can instantiate the connector.
thorntail.messaging-activemq.servers.KEY.connectors.KEY.params: A key-value pair understood by the connector factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.connectors.KEY.socket-binding: The socket binding that the connector will use to create connections.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.binding-names: The names of all bindings (both queues and diverts) bound to this address.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.number-of-bytes-per-page: The number of bytes used by each page for this address.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.number-of-pages: The number of pages used by this address.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.queue-names: The names of the queues associated with the address.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.consume: This permission allows the user to consume a message from a queue bound to matching addresses.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.create-durable-queue: This permission allows the user to create a durable queue.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.create-non-durable-queue: This permission allows the user to create a temporary queue.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.delete-durable-queue: This permission allows the user to delete a durable queue.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.delete-non-durable-queue: This permission allows the user to delete a temporary queue.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.manage: This permission allows the user to invoke management operations by sending management messages to the management address.
thorntail.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.send: This permission allows the user to send a message to matching addresses.
thorntail.messaging-activemq.servers.KEY.create-bindings-dir: Whether the server should create the bindings directory on start up.
thorntail.messaging-activemq.servers.KEY.create-journal-dir: Whether the server should create the journal directory on start up.
thorntail.messaging-activemq.servers.KEY.discovery-groups.KEY.initial-wait-timeout: Period, in ms, to wait for an initial broadcast to give us at least one node in the cluster.
thorntail.messaging-activemq.servers.KEY.discovery-groups.KEY.jgroups-channel: The name used by a JGroups channel to join a cluster.
thorntail.messaging-activemq.servers.KEY.discovery-groups.KEY.jgroups-stack: The name of a stack defined in the org.jboss.as.clustering.jgroups subsystem that is used to form a cluster.
thorntail.messaging-activemq.servers.KEY.discovery-groups.KEY.refresh-timeout: Period the discovery group waits after receiving the last broadcast from a particular server before removing that server’s connector pair entry from its list.
thorntail.messaging-activemq.servers.KEY.discovery-groups.KEY.socket-binding: The discovery group socket binding.
thorntail.messaging-activemq.servers.KEY.diverts.KEY.divert-address: Address to divert from
thorntail.messaging-activemq.servers.KEY.diverts.KEY.exclusive: Whether the divert is exclusive, meaning that the message is diverted to the new address, and does not go to the old address at all.
thorntail.messaging-activemq.servers.KEY.diverts.KEY.filter: An optional filter string. If specified then only messages which match the filter expression specified will be diverted. The filter string follows the ActiveMQ filter expression syntax described in the ActiveMQ documentation.
thorntail.messaging-activemq.servers.KEY.diverts.KEY.forwarding-address: Address to divert to
thorntail.messaging-activemq.servers.KEY.diverts.KEY.routing-name: Routing name of the divert
thorntail.messaging-activemq.servers.KEY.diverts.KEY.transformer-class-name: The name of a class used to transform the message’s body or properties before it is diverted.
thorntail.messaging-activemq.servers.KEY.elytron-domain: The name of the Elytron security domain used to verify user and role information.
thorntail.messaging-activemq.servers.KEY.grouping-handlers.KEY.group-timeout: How long a group binding will be used, -1 means for ever. Bindings are removed after this wait elapses (valid for both LOCAL and REMOTE handlers).
thorntail.messaging-activemq.servers.KEY.grouping-handlers.KEY.grouping-handler-address: A reference to a cluster connection and the address it uses.
thorntail.messaging-activemq.servers.KEY.grouping-handlers.KEY.reaper-period: How often the reaper will be run to check for timed out group bindings (only valid for LOCAL handlers).
thorntail.messaging-activemq.servers.KEY.grouping-handlers.KEY.timeout: How long to wait for a handling decision to be made; an exception will be thrown during the send if this timeout is reached, ensuring that strict ordering is kept.
thorntail.messaging-activemq.servers.KEY.grouping-handlers.KEY.type: Whether the handler is the single "Local" handler for the cluster, which makes handling decisions, or a "Remote" handler which converses with the local handler.
thorntail.messaging-activemq.servers.KEY.http-acceptors.KEY.http-listener: The Undertow’s http-listener that handles HTTP upgrade requests.
thorntail.messaging-activemq.servers.KEY.http-acceptors.KEY.params: A key-value pair understood by the acceptor factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.http-acceptors.KEY.upgrade-legacy: Also accepts to upgrade HTTP request from legacy (HornetQ) clients.
thorntail.messaging-activemq.servers.KEY.http-connectors.KEY.endpoint: The http-acceptor that serves as the endpoint of this http-connector.
thorntail.messaging-activemq.servers.KEY.http-connectors.KEY.params: A key-value pair understood by the connector factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.http-connectors.KEY.server-name: The name of the ActiveMQ Artemis server that will be connected to on the remote server. If undefined, the name of the parent ActiveMQ Artemis server will be used (suitable if the http-connector is used to connect to the parent server)
thorntail.messaging-activemq.servers.KEY.http-connectors.KEY.socket-binding: The socket binding that the connector will use to create connections.
thorntail.messaging-activemq.servers.KEY.id-cache-size: The size of the cache for pre-creating message IDs.
thorntail.messaging-activemq.servers.KEY.in-vm-acceptors.KEY.params: A key-value pair understood by the acceptor factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.in-vm-acceptors.KEY.server-id: The server id.
thorntail.messaging-activemq.servers.KEY.in-vm-acceptors.KEY.started: Whether this acceptor is started.
thorntail.messaging-activemq.servers.KEY.in-vm-connectors.KEY.params: A key-value pair understood by the connector factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.in-vm-connectors.KEY.server-id: The server id.
thorntail.messaging-activemq.servers.KEY.incoming-interceptors: The list of incoming interceptor classes used by this server.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.consumer-count: The number of consumers consuming messages from this queue.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.dead-letter-address: The address to send dead messages to.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.delivering-count: The number of messages that this queue is currently delivering to its consumers.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.durable: Whether the queue is durable or not.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.entries: The jndi names the queue will be bound to.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.expiry-address: The address to send expired messages to.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.legacy-entries: The jndi names the queue will be bound to.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.message-count: The number of messages currently in this queue.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.messages-added: The number of messages added to this queue since it was created.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.paused: Whether the queue is paused.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.queue-address: The queue address defines what address is used for routing messages.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.scheduled-count: The number of scheduled messages in this queue.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.selector: The queue selector.
thorntail.messaging-activemq.servers.KEY.jms-queues.KEY.temporary: Whether the queue is temporary.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.delivering-count: The number of messages that this queue is currently delivering to its consumers.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.durable-message-count: The number of messages for all durable subscribers for this topic.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.durable-subscription-count: The number of durable subscribers for this topic.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.entries: The jndi names the topic will be bound to.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.legacy-entries: The legacy jndi names the topic will be bound to.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.message-count: The number of messages currently in this queue.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.messages-added: The number of messages added to this queue since it was created.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.non-durable-message-count: The number of messages for all non-durable subscribers for this topic.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.non-durable-subscription-count: The number of non-durable subscribers for this topic.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.subscription-count: The number of (durable and non-durable) subscribers for this topic.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.temporary: Whether the topic is temporary.
thorntail.messaging-activemq.servers.KEY.jms-topics.KEY.topic-address: The address the topic points to.
thorntail.messaging-activemq.servers.KEY.jmx-domain: The JMX domain used to register internal ActiveMQ MBeans in the MBeanServer.
thorntail.messaging-activemq.servers.KEY.jmx-management-enabled: Whether ActiveMQ should expose its internal management API via JMX. This is not recommended, as accessing these MBeans can lead to inconsistent configuration.
thorntail.messaging-activemq.servers.KEY.journal-bindings-table: Name of the JDBC table to store the bindings.
thorntail.messaging-activemq.servers.KEY.journal-buffer-size: The size of the internal buffer on the journal.
thorntail.messaging-activemq.servers.KEY.journal-buffer-timeout: The timeout (in nanoseconds) used to flush internal buffers on the journal.
thorntail.messaging-activemq.servers.KEY.journal-compact-min-files: The minimal number of journal data files before we can start compacting.
thorntail.messaging-activemq.servers.KEY.journal-compact-percentage: The percentage of live data on which we consider compacting the journal.
thorntail.messaging-activemq.servers.KEY.journal-database: Type of the database (can be used to customize SQL statements). If this attribute is not specified, the type of the database will be determined based on the DataSource metadata.
thorntail.messaging-activemq.servers.KEY.journal-datasource: Name of the DataSource for the JDBC store.
thorntail.messaging-activemq.servers.KEY.journal-directory-path.path: The actual filesystem path. Treated as an absolute path, unless the 'relative-to' attribute is specified, in which case the value is treated as relative to that path. If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: If this value is already absolute, then the value is directly used. Otherwise the runtime pathname is resolved in a system-dependent way. On UNIX systems, a relative pathname is made absolute by resolving it against the current user directory. On Microsoft Windows systems, a relative pathname is made absolute by resolving it against the current directory of the drive named by the pathname, if any; if not, it is resolved against the current user directory.
thorntail.messaging-activemq.servers.KEY.journal-directory-path.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute. The standard paths provided by the system include: jboss.home - the root directory of the JBoss AS distribution, user.home - user’s home directory, user.dir - user’s current working directory, java.home - java installation directory, jboss.server.base.dir - root directory for an individual server instance, jboss.server.data.dir - directory the server will use for persistent data file storage, jboss.server.log.dir - directory the server will use for log file storage, jboss.server.tmp.dir - directory the server will use for temporary file storage, and jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances.
thorntail.messaging-activemq.servers.KEY.journal-file-size: The size (in bytes) of each journal file.
thorntail.messaging-activemq.servers.KEY.journal-jdbc-network-timeout: The timeout used by the JDBC connection to detect network issues.
thorntail.messaging-activemq.servers.KEY.journal-jms-bindings-table: Name of the JDBC table to store the JMS bindings.
thorntail.messaging-activemq.servers.KEY.journal-large-messages-table: Name of the JDBC table to store the large messages.
thorntail.messaging-activemq.servers.KEY.journal-max-io: The maximum number of write requests that can be in the AIO queue at any one time.
thorntail.messaging-activemq.servers.KEY.journal-messages-table: Name of the JDBC table to store the messages.
thorntail.messaging-activemq.servers.KEY.journal-min-files: How many journal files to pre-create.
thorntail.messaging-activemq.servers.KEY.journal-page-store-table: Name of the JDBC table to store pages.
thorntail.messaging-activemq.servers.KEY.journal-pool-files: The number of journal files that can be reused. ActiveMQ will create as many files as needed however when reclaiming files it will shrink back to the value (-1 means no limit).
thorntail.messaging-activemq.servers.KEY.journal-sync-non-transactional: Whether to wait for non transaction data to be synced to the journal before returning a response to the client.
thorntail.messaging-activemq.servers.KEY.journal-sync-transactional: Whether to wait for transaction data to be synchronized to the journal before returning a response to the client.
thorntail.messaging-activemq.servers.KEY.journal-type: The type of journal to use.
thorntail.messaging-activemq.servers.KEY.large-messages-directory-path.path: The actual filesystem path. Treated as an absolute path, unless the 'relative-to' attribute is specified, in which case the value is treated as relative to that path. If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: If this value is already absolute, then the value is directly used. Otherwise the runtime pathname is resolved in a system-dependent way. On UNIX systems, a relative pathname is made absolute by resolving it against the current user directory. On Microsoft Windows systems, a relative pathname is made absolute by resolving it against the current directory of the drive named by the pathname, if any; if not, it is resolved against the current user directory.
thorntail.messaging-activemq.servers.KEY.large-messages-directory-path.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute. The standard paths provided by the system include: jboss.home - the root directory of the JBoss AS distribution, user.home - user’s home directory, user.dir - user’s current working directory, java.home - java installation directory, jboss.server.base.dir - root directory for an individual server instance, jboss.server.data.dir - directory the server will use for persistent data file storage, jboss.server.log.dir - directory the server will use for log file storage, jboss.server.tmp.dir - directory the server will use for temporary file storage, and jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.auto-group: Whether or not message grouping is automatically used
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.block-on-acknowledge: True to set block on acknowledge.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.block-on-durable-send: True to set block on durable send.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.block-on-non-durable-send: True to set block on non durable send.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.cache-large-message-client: True to cache large messages.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.call-failover-timeout: The timeout to use when fail over is in process (in ms).
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.call-timeout: The call time out.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.client-failure-check-period: The client failure check period.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.client-id: The client id.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.compress-large-messages: Whether large messages should be compressed.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.confirmation-window-size: The confirmation window size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.connection-load-balancing-policy-class-name: Name of a class implementing a client-side load balancing policy that a client can use to load balance sessions across different nodes in a cluster.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.connection-ttl: The connection ttl.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.connectors: Defines the connectors. These are stored in a map by connector name (with an undefined value). It is possible to pass a list of connector names when writing this attribute.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.consumer-max-rate: The consumer max rate.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.consumer-window-size: The consumer window size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.discovery-group: The discovery group name.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.dups-ok-batch-size: The dups ok batch size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.entries: The jndi names the connection factory should be bound to.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.factory-type: The type of connection factory.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.failover-on-initial-connection: True to fail over on initial connection.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.group-id: The group id.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.ha: Whether the connection factory supports High Availability.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.initial-connect-attempts: The number of attempts for the initial connection to the server.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.initial-message-packet-size: The initial size of messages created through this factory.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.max-retry-interval: The max retry interval.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.min-large-message-size: The min large message size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.pre-acknowledge: True to pre-acknowledge.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.producer-max-rate: The producer max rate.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.producer-window-size: The producer window size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.reconnect-attempts: The reconnect attempts.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.retry-interval: The retry interval.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.retry-interval-multiplier: The retry interval multiplier.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.scheduled-thread-pool-max-size: The scheduled thread pool max size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.thread-pool-max-size: The thread pool max size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.transaction-batch-size: The transaction batch size.
thorntail.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.use-global-pools: True to use global pools.
thorntail.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down: Configure whether this server send its messages to another live server in the scale-down cluster when it is shutdown cleanly.
thorntail.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-cluster-name: Name of the cluster used to scale down.
thorntail.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-connectors: List of connectors used to form the scale-down cluster.
thorntail.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-discovery-group: Name of the discovery group used to build the scale-down cluster
thorntail.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-group-name: Name of the group used to scale down.
thorntail.messaging-activemq.servers.KEY.log-journal-write-rate: Whether to periodically log the journal’s write rate and flush rate.
thorntail.messaging-activemq.servers.KEY.management-address: Address to send management messages to.
thorntail.messaging-activemq.servers.KEY.management-notification-address: The name of the address that consumers bind to to receive management notifications.
thorntail.messaging-activemq.servers.KEY.memory-measure-interval: Frequency to sample JVM memory in ms (or -1 to disable memory sampling)
thorntail.messaging-activemq.servers.KEY.memory-warning-threshold: Percentage of available memory which if exceeded results in a warning log
thorntail.messaging-activemq.servers.KEY.message-counter-max-day-history: How many days to keep message counter history.
thorntail.messaging-activemq.servers.KEY.message-counter-sample-period: The sample period (in ms) to use for message counters.
thorntail.messaging-activemq.servers.KEY.message-expiry-scan-period: How often (in ms) to scan for expired messages.
thorntail.messaging-activemq.servers.KEY.message-expiry-thread-priority: The priority of the thread expiring messages.
thorntail.messaging-activemq.servers.KEY.outgoing-interceptors: The list of outgoing interceptor classes used by this server.
thorntail.messaging-activemq.servers.KEY.override-in-vm-security: Whether the ActiveMQ server will override security credentials for in-vm connections.
thorntail.messaging-activemq.servers.KEY.page-max-concurrent-io: The maximum number of concurrent reads allowed on paging
thorntail.messaging-activemq.servers.KEY.paging-directory-path.path: The actual filesystem path. Treated as an absolute path, unless the 'relative-to' attribute is specified, in which case the value is treated as relative to that path. If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: If this value is already absolute, then the value is directly used. Otherwise the runtime pathname is resolved in a system-dependent way. On UNIX systems, a relative pathname is made absolute by resolving it against the current user directory. On Microsoft Windows systems, a relative pathname is made absolute by resolving it against the current directory of the drive named by the pathname, if any; if not, it is resolved against the current user directory.
thorntail.messaging-activemq.servers.KEY.paging-directory-path.relative-to: The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute. The standard paths provided by the system include: jboss.home - the root directory of the JBoss AS distribution, user.home - user’s home directory, user.dir - user’s current working directory, java.home - java installation directory, jboss.server.base.dir - root directory for an individual server instance, jboss.server.data.dir - directory the server will use for persistent data file storage, jboss.server.log.dir - directory the server will use for log file storage, jboss.server.tmp.dir - directory the server will use for temporary file storage, and jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances.
thorntail.messaging-activemq.servers.KEY.perf-blast-pages: Number of pages to add to check the journal performance (only meant to be used to test performance of pages).
thorntail.messaging-activemq.servers.KEY.persist-delivery-count-before-delivery: Whether the delivery count is persisted before delivery. False means that this only happens after a message has been cancelled.
thorntail.messaging-activemq.servers.KEY.persist-id-cache: Whether IDs are persisted to the journal.
thorntail.messaging-activemq.servers.KEY.persistence-enabled: Whether the server will use the file based journal for persistence.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.allow-local-transactions: Allow local transactions for outbond JMS Sessions (it does not apply to JMSContext that explicitly disallows it).
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.auto-group: The autogroup.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.block-on-acknowledge: True to set block on acknowledge.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.block-on-durable-send: True to set block on durable send.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.block-on-non-durable-send: True to set block on non durable send.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.cache-large-message-client: True to cache large messages.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.call-failover-timeout: The timeout to use when fail over is in process (in ms).
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.call-timeout: The call time out.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.client-failure-check-period: The client failure check period.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.client-id: The client id.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.compress-large-messages: Whether large messages should be compressed.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.confirmation-window-size: The confirmation window size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.connection-load-balancing-policy-class-name: Name of a class implementing a client-side load balancing policy that a client can use to load balance sessions across different nodes in a cluster.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.connection-ttl: The connection ttl.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.connectors: Defines the connectors. These are stored in a map by connector name (with an undefined value). It is possible to pass a list of connector names when writing this attribute.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.consumer-max-rate: The consumer max rate.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.consumer-window-size: The consumer window size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.credential-reference: Credential (from Credential Store) to authenticate the pooled connection factory
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.deserialization-black-list: A list of class names (separated by whitespaces) that are black-listed to be used in serialization of JMS ObjectMessage.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.deserialization-white-list: A list of class names (separated by whitespaces) that are white-listed to be used in serialization of JMS ObjectMessage.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.discovery-group: The discovery group name.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.dups-ok-batch-size: The dups ok batch size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.enlistment-trace: Enables IronJacamar to record enlistment traces for this pooled-connection-factory. This attribute is undefined by default and the behaviour is driven by the presence of the ironjacamar.disable_enlistment_trace system property.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.entries: The jndi names the connection factory should be bound to.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.failover-on-initial-connection: True to fail over on initial connection.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.group-id: The group id.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.ha: Whether the connection factory supports High Availability.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.initial-connect-attempts: The number of attempts to connect initially with this factory.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.initial-message-packet-size: The initial size of messages created through this factory.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.jndi-params: The JNDI params to use for locating the destination for incoming connections.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.managed-connection-pool: The class name of the managed connection pool used by this pooled-connection-factory.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.max-pool-size: The maximum size for the pool
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.max-retry-interval: The max retry interval.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.min-large-message-size: The min large message size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.min-pool-size: The minimum size for the pool
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.password: The default password to use with this connection factory. This is only needed when pointing the connection factory to a remote host.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.pre-acknowledge: True to pre-acknowledge.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.producer-max-rate: The producer max rate.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.producer-window-size: The producer window size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.protocol-manager-factory: The protocol manager factory used by this pooled connection factory.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.rebalance-connections: Rebalance inbound connections when cluster topology changes.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.reconnect-attempts: The reconnect attempts. By default, a pooled connection factory will try to reconnect infinitely to the messaging server(s).
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.retry-interval: The retry interval.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.retry-interval-multiplier: The retry interval multiplier.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.scheduled-thread-pool-max-size: The scheduled thread pool max size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.setup-attempts: The number of times to set up an MDB endpoint
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.setup-interval: The interval between attempts at setting up an MDB endpoint.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.statistics-enabled: Define whether runtime statistics are enabled.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.thread-pool-max-size: The thread pool max size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.transaction: The type of transaction supported by this pooled connection factory (can be LOCAL, NONE or XA, default is XA).
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.transaction-batch-size: The transaction batch size.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-auto-recovery: True to use auto recovery.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-global-pools: True to use global pools.
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-jndi: Use JNDI to locate the destination for incoming connections
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-local-tx: Use a local transaction for incoming sessions
thorntail.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.user: The default username to use with this connection factory. This is only needed when pointing the connection factory to a remote host.
thorntail.messaging-activemq.servers.KEY.queues.KEY.consumer-count: The number of consumers consuming messages from this queue.
thorntail.messaging-activemq.servers.KEY.queues.KEY.dead-letter-address: The address to send the queue’s dead messages to.
thorntail.messaging-activemq.servers.KEY.queues.KEY.delivering-count: The number of messages that this queue is currently delivering to its consumers.
thorntail.messaging-activemq.servers.KEY.queues.KEY.durable: Defines whether the queue is durable.
thorntail.messaging-activemq.servers.KEY.queues.KEY.expiry-address: The address to send the queue’s expired messages to.
thorntail.messaging-activemq.servers.KEY.queues.KEY.filter: A queue message filter definition. An undefined or empty filter will match all messages.
thorntail.messaging-activemq.servers.KEY.queues.KEY.id: The id of the queue.
thorntail.messaging-activemq.servers.KEY.queues.KEY.message-count: The number of messages currently in this queue.
thorntail.messaging-activemq.servers.KEY.queues.KEY.messages-added: The number of messages added to this queue since it was created.
thorntail.messaging-activemq.servers.KEY.queues.KEY.paused: Whether the queue is paused.
thorntail.messaging-activemq.servers.KEY.queues.KEY.queue-address: The queue address defines what address is used for routing messages.
thorntail.messaging-activemq.servers.KEY.queues.KEY.scheduled-count: The number of scheduled messages in this queue.
thorntail.messaging-activemq.servers.KEY.queues.KEY.temporary: Whether the queue is temporary.
thorntail.messaging-activemq.servers.KEY.remote-acceptors.KEY.params: A key-value pair understood by the acceptor factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.remote-acceptors.KEY.socket-binding: The socket binding that the acceptor will use to accept connections.
thorntail.messaging-activemq.servers.KEY.remote-acceptors.KEY.started: Whether this acceptor is started.
thorntail.messaging-activemq.servers.KEY.remote-connectors.KEY.params: A key-value pair understood by the connector factory-class and used to configure it.
thorntail.messaging-activemq.servers.KEY.remote-connectors.KEY.socket-binding: The socket binding that the connector will use to create connections.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.backup-port-offset: The offset to use for the Connectors and Acceptors when creating a new backup server.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.backup-request-retries: How many times the live server will try to request a backup, -1 means for ever.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.backup-request-retry-interval: How long (in ms) to wait for retries between attempts to request a backup server.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.excluded-connectors: The connectors that must not have their port offset.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.master-configuration.check-for-live-server: Whether to check the cluster for another server using the same server ID when starting up.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.master-configuration.cluster-name: Name of the cluster used for replication. If it is undefined, the name of the first cluster connection defined in the configuration will be used.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.master-configuration.group-name: If set, backup servers will only pair with live servers with matching group-name.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.master-configuration.initial-replication-sync-timeout: How long to wait until the initiation replication is synchronized.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.max-backups: Whether or not this live server will accept backup requests from other live servers.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.request-backup: If true then the server will request a backup on another node.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.allow-failback: Whether a server will automatically stop when a another places a request to take over its place. The use case is when a regular server stops and its backup takes over its duties, later the main server restarts and requests the server (the former backup) to stop operating.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.cluster-name: Name of the cluster used for replication. If it is undefined, the name of the first cluster connection defined in the configuration will be used.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.group-name: If set, backup servers will only pair with live servers with matching group-name.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.initial-replication-sync-timeout: How long to wait until the initiation replication is synchronized.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.max-saved-replicated-journal-size: This specifies how many times a replicated backup server can restart after moving its files on start. Once there are this number of backup journal files the server will stop permanently after if fails back.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.restart-backup: Will this server, if a backup, restart once it has been stopped because of failback or scaling down.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down: Configure whether this server send its messages to another live server in the scale-down cluster when it is shutdown cleanly.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-cluster-name: Name of the cluster used to scale down.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-connectors: List of connectors used to form the scale-down cluster.
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-discovery-group: Name of the discovery group used to build the scale-down cluster
thorntail.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-group-name: Name of the group used to scale down.
thorntail.messaging-activemq.servers.KEY.replication-master-ha-policy.check-for-live-server: Whether to check the cluster for another server using the same server ID when starting up.
thorntail.messaging-activemq.servers.KEY.replication-master-ha-policy.cluster-name: Name of the cluster used for replication. If it is undefined, the name of the first cluster connection defined in the configuration will be used.
thorntail.messaging-activemq.servers.KEY.replication-master-ha-policy.group-name: If set, backup servers will only pair with live servers with matching group-name.
thorntail.messaging-activemq.servers.KEY.replication-master-ha-policy.initial-replication-sync-timeout: How long to wait until the initiation replication is synchronized.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.allow-failback: Whether a server will automatically stop when a another places a request to take over its place. The use case is when a regular server stops and its backup takes over its duties, later the main server restarts and requests the server (the former backup) to stop operating.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.cluster-name: Name of the cluster used for replication. If it is undefined, the name of the first cluster connection defined in the configuration will be used.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.group-name: If set, backup servers will only pair with live servers with matching group-name.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.initial-replication-sync-timeout: How long to wait until the initiation replication is synchronized.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.max-saved-replicated-journal-size: This specifies how many times a replicated backup server can restart after moving its files on start. Once there are this number of backup journal files the server will stop permanently after if fails back.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.restart-backup: Will this server, if a backup, restart once it has been stopped because of failback or scaling down.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down: Configure whether this server send its messages to another live server in the scale-down cluster when it is shutdown cleanly.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-cluster-name: Name of the cluster used to scale down.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-connectors: List of connectors used to form the scale-down cluster.
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-discovery-group: Name of the discovery group used to build the scale-down cluster
thorntail.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-group-name: Name of the group used to scale down.
thorntail.messaging-activemq.servers.KEY.run-sync-speed-test: Whether on startup to perform a diagnostic test on how fast your disk can sync. Useful when determining performance issues.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.consumer-count: The number of consumers consuming messages from this queue.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.dead-letter-address: The address to send the queue’s dead messages to.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.delivering-count: The number of messages that this queue is currently delivering to its consumers.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.durable: Defines whether the queue is durable.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.expiry-address: The address to send the queue’s expired messages to.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.filter: A queue message filter definition. An undefined or empty filter will match all messages.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.id: The id of the queue.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.message-count: The number of messages currently in this queue.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.messages-added: The number of messages added to this queue since it was created.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.paused: Whether the queue is paused.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.queue-address: The queue address defines what address is used for routing messages.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.scheduled-count: The number of scheduled messages in this queue.
thorntail.messaging-activemq.servers.KEY.runtime-queues.KEY.temporary: Whether the queue is temporary.
thorntail.messaging-activemq.servers.KEY.scheduled-thread-pool-max-size: The number of threads that the main scheduled thread pool has.
thorntail.messaging-activemq.servers.KEY.security-enabled: Whether security is enabled.
thorntail.messaging-activemq.servers.KEY.security-invalidation-interval: How long (in ms) to wait before invalidating the security cache.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.consume: This permission allows the user to consume a message from a queue bound to matching addresses.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.create-durable-queue: This permission allows the user to create a durable queue.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.create-non-durable-queue: This permission allows the user to create a temporary queue.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.delete-durable-queue: This permission allows the user to delete a durable queue.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.delete-non-durable-queue: This permission allows the user to delete a temporary queue.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.manage: This permission allows the user to invoke management operations by sending management messages to the management address.
thorntail.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.send: This permission allows the user to send a message to matching addresses.
thorntail.messaging-activemq.servers.KEY.server-dump-interval: How often to dump basic runtime information to the server log. A value less than 1 disables this feature.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.backup-port-offset: The offset to use for the Connectors and Acceptors when creating a new backup server.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.backup-request-retries: How many times the live server will try to request a backup, -1 means for ever.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.backup-request-retry-interval: How long (in ms) to wait for retries between attempts to request a backup server.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.master-configuration.failover-on-server-shutdown: Whether the server must failover when it is normally shutdown.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.max-backups: Whether or not this live server will accept backup requests from other live servers.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.request-backup: If true then the server will request a backup on another node.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.allow-failback: Whether a server will automatically stop when a another places a request to take over its place. The use case is when a regular server stops and its backup takes over its duties, later the main server restarts and requests the server (the former backup) to stop operating.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.failover-on-server-shutdown: Whether the server must failover when it is normally shutdown.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.restart-backup: Will this server, if a backup, restart once it has been stopped because of failback or scaling down.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down: Configure whether this server send its messages to another live server in the scale-down cluster when it is shutdown cleanly.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-cluster-name: Name of the cluster used to scale down.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-connectors: List of connectors used to form the scale-down cluster.
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-discovery-group: Name of the discovery group used to build the scale-down cluster
thorntail.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-group-name: Name of the group used to scale down.
thorntail.messaging-activemq.servers.KEY.shared-store-master-ha-policy.failover-on-server-shutdown: Whether the server must failover when it is normally shutdown.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.allow-failback: Whether a server will automatically stop when a another places a request to take over its place. The use case is when a regular server stops and its backup takes over its duties, later the main server restarts and requests the server (the former backup) to stop operating.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.failover-on-server-shutdown: Whether the server must failover when it is normally shutdown.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.restart-backup: Will this server, if a backup, restart once it has been stopped because of failback or scaling down.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down: Configure whether this server send its messages to another live server in the scale-down cluster when it is shutdown cleanly.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-cluster-name: Name of the cluster used to scale down.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-connectors: List of connectors used to form the scale-down cluster.
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-discovery-group: Name of the discovery group used to build the scale-down cluster
thorntail.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-group-name: Name of the group used to scale down.
thorntail.messaging-activemq.servers.KEY.started: Whether this server is started.
thorntail.messaging-activemq.servers.KEY.statistics-enabled: Whether gathering of statistics such as message counters are enabled.
thorntail.messaging-activemq.servers.KEY.thread-pool-max-size: The number of threads that the main thread pool has. -1 means no limit.
thorntail.messaging-activemq.servers.KEY.transaction-timeout: How long (in ms) before a transaction can be removed from the resource manager after create time.
thorntail.messaging-activemq.servers.KEY.transaction-timeout-scan-period: How often (in ms) to scan for timeout transactions.
thorntail.messaging-activemq.servers.KEY.version: The server’s version.
thorntail.messaging-activemq.servers.KEY.wild-card-routing-enabled: Whether the server supports wild card routing.
thorntail.messaging.remote: Flag to enable the remote connection
thorntail.messaging.remote.host: Host of the remote connection
thorntail.messaging.remote.jndi-name: JNDI name of the remote connection
thorntail.messaging.remote.name: Name of the remote connection
thorntail.messaging.remote.port: Port of the remote connection

6.42. MicroProfile

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile</artifactId>
</dependency>

6.42.1. MicroProfile Config

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-config</artifactId>
</dependency>

Configuration

thorntail.microprofile.config.config-source-providers.KEY.attribute-class: Class of the ConfigSourceProvider to load
thorntail.microprofile.config.config-sources.KEY.attribute-class: Class of the config source to load
thorntail.microprofile.config.config-sources.KEY.dir: Directory that is scanned to config properties for this config source (file names are key, file content are value)
thorntail.microprofile.config.config-sources.KEY.ordinal: Ordinal value for the config source
thorntail.microprofile.config.config-sources.KEY.properties: Properties configured for this config source

6.42.2. MicroProfile Fault Tolerance

This fraction implements the Eclipse MicroProfile Fault Tolerance API. The implementation depends on the Hystrix fraction, which is added transitively into your application. Use standard configuration mechanisms to configure Hystrix properties in your application.

Bulkhead fallback rejection

If you use the @Bulkhead pattern together with some @Fallback logic to limit the number of concurrent requests, an invocation may still result in an exception.

Semaphore Isolation

For semaphore-style @Bulkhead a BulkheadException may be thrown if the maximum concurrent limit is reached. To avoid that, set the thorntail.hystrix.command.default.fallback.isolation.semaphore.maxConcurrentRequests property to increase the limit.

Thread Isolation

For @Bulkhead used together with @Asynchronous a RejectedExecutionException may be thrown if the maximum concurrent limit is reached. To avoid that, set the thorntail.hystrix.threadpool.default.maximumSize property to increase the limit. Also don’t forget to set the thorntail.hystrix.threadpool.default.allowMaximumSizeToDivergeFromCoreSize property to true.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-fault-tolerance</artifactId>
</dependency>

Configuration

thorntail.microprofile.fault-tolerance.synchronous-circuit-breaker: Enable/disable synchronous circuit breaker functionality. If disabled, CircuitBreaker#successThreshold() of value greater than 1 is not supported. Moreover, circuit breaker does not necessarily transition from CLOSED to OPEN immediately when a fault tolerance operation completes. However, applications are encouraged to disable this feature on high-volume circuits.

6.42.3. MicroProfile Health

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-health</artifactId>
</dependency>

Configuration

thorntail.microprofile.health.security-realm: Security realm configuration

6.42.4. MicroProfile JWT RBAC Auth

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-jwt</artifactId>
</dependency>

Configuration

thorntail.microprofile.jwt.default-missing-method-permissions-deny-access: If a JAX-RS resource has no class-level security metadata, then if this property is set to true and at least one resource method has security metadata all other resource methods without security metadata have an implicit @DenyAll, otherwise resource methods without security metadata are not secured
thorntail.microprofile.jwt.token.exp-grace-period: The JWT token expiration grace period in seconds
thorntail.microprofile.jwt.token.issued-by: The URI of the JWT token issuer
thorntail.microprofile.jwt.token.jwks-refresh-interval: The interval at which the JWKS URI should be queried for keys (in minutes).
thorntail.microprofile.jwt.token.jwks-uri: The JWKS URI from which to load public keys (if 'signer-pub-key' is set, this setting is ignored).
thorntail.microprofile.jwt.token.signer-pub-key: The public key of the JWT token signer. Can be prefixed 'file:' or 'classpath:' for key assets, otherwise the key contents are expected

6.42.5. MicroProfile Metrics

This fraction implements the MicroProfile Metrics 1.0 specification.

To use this in your project you need the following in your pom.xml

   <dependency>
      <groupId>io.thorntail</groupId>
      <artifactId>microprofile-metrics</artifactId>
    </dependency>

There is no need to include the MicroProfile Metrics API dependency, as it comes with the fraction.

By default the base metrics and vendor metrics of the server are exposed as required by the spec.

Note	Exposing application metrics currently only works if you chose `war` packaging of your application

<project>
  <groupId>org.example</groupId>
  <artifactId>thorntail-demo</artifactId>
  <packaging>war</packaging> (1)

war packaging

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-metrics</artifactId>
</dependency>

6.42.6. MicroProfile OpenAPI

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-openapi</artifactId>
</dependency>

6.42.7. MicroProfile OpenTracing

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-opentracing</artifactId>
</dependency>

6.42.8. MicroProfile Rest Client

CDI Interceptors Support

In general, Rest Client proxies are not created by the CDI container and therefore method invocations do not pass through CDI interceptors. In Thorntail, however, you can associate business method interceptors (denoted by the @AroundInvoke annotation) with a Rest Client proxy by using interceptor bindings. This feature is non-portable. The primary use case is the support of MicroProfile Fault Tolerance annotations, for example:

import org.eclipse.microprofile.faulttolerance.Retry;

@Path("/v1")
interface MyClient {

    @Retry(maxRetries = 3) // Retry on any exception thrown
    @GET
    @Path("/hello")
    String hello();
}

Note	The `org.eclipse.microprofile.faulttolerance.Asynchronous` annotation is currently not supported because the underlying RESTEasy client is not able to handle the `java.util.concurrent.Future` return types.

RestClientProxy

In addition to the MicroProfile Rest Client specification, every Rest Client proxy implements io.smallrye.restclient.RestClientProxy interface which allows you to:

obtain the underlying javax.ws.rs.client.Client instance

release all associated resources, for example:

public void hello() {
   MyClient myClient = RestClientBuilder.newBuilder().build(MyClient.class);
   myClient.hello();
   // Finally release all associated resources
   ((RestClientProxy) helloClient).close();
}

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>microprofile-restclient</artifactId>
</dependency>

6.43. Modcluster

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>mod_cluster</artifactId>
</dependency>

Configuration

swarm.modcluster.configuration-mod-cluster-config.advertise: Whether to enable multicast-based advertise mechanism.
swarm.modcluster.configuration-mod-cluster-config.advertise-security-key: If specified, reverse proxy advertisements checksums will be verified using this value as a salt.
swarm.modcluster.configuration-mod-cluster-config.advertise-socket: Name of socket binding to use for the advertise socket.
swarm.modcluster.configuration-mod-cluster-config.auto-enable-contexts: If false, the contexts are registered with the reverse proxy as disabled; they need to be enabled via the enable-context operation or via mod_cluster_manager console.
swarm.modcluster.configuration-mod-cluster-config.balancer: The name of the balancer on the reverse proxy to register with.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.custom-load-metrics.KEY.attribute-class: Class name of the custom metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.custom-load-metrics.KEY.capacity: Capacity of the metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.custom-load-metrics.KEY.property: Properties for the metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.custom-load-metrics.KEY.weight: Weight of the metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.decay: Decay
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.history: History
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.load-metrics.KEY.capacity: Capacity of the metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.load-metrics.KEY.property: Properties for the metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.load-metrics.KEY.type: Type of the metric
swarm.modcluster.configuration-mod-cluster-config.configuration-dynamic-load-provider.load-metrics.KEY.weight: Weight of the metric.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.ca-certificate-file: Certificate authority.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.ca-revocation-url: Certificate authority revocation list.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.certificate-key-file: Key file for the certificate.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.cipher-suite: The allowed cipher suite.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.key-alias: The key alias.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.password: Password.
swarm.modcluster.configuration-mod-cluster-config.configuration-ssl.protocol: The SSL protocols that are enabled.
swarm.modcluster.configuration-mod-cluster-config.connector: The name of Undertow listener that will be registered with the reverse proxy.
swarm.modcluster.configuration-mod-cluster-config.excluded-contexts: List of contexts to exclude from registration with the reverse proxies.
swarm.modcluster.configuration-mod-cluster-config.flush-packets: Whether to enable packet flushing on the reverse proxy.
swarm.modcluster.configuration-mod-cluster-config.flush-wait: Time to wait before flushing packets on the reverse proxy.
swarm.modcluster.configuration-mod-cluster-config.load-balancing-group: Name of the load balancing group this node belongs to.
swarm.modcluster.configuration-mod-cluster-config.max-attempts: Number of times the reverse proxy will attempt to send a given request to a worker before giving up.
swarm.modcluster.configuration-mod-cluster-config.node-timeout: Timeout (in seconds) for proxy connections to a node. That is the time mod_cluster will wait for the back-end response before returning an error.
swarm.modcluster.configuration-mod-cluster-config.ping: Time (in seconds) in which to wait for a pong answer to a ping.
swarm.modcluster.configuration-mod-cluster-config.proxies: List of reverse proxies for mod_cluster to register with defined by outbound-socket-binding in socket-binding-group.
swarm.modcluster.configuration-mod-cluster-config.proxy-url: Base URL for MCMP requests.
swarm.modcluster.configuration-mod-cluster-config.session-draining-strategy: Session draining strategy used during undeployment of a web application.
swarm.modcluster.configuration-mod-cluster-config.simple-load-provider: Simple load provider configuration.
swarm.modcluster.configuration-mod-cluster-config.smax: Soft maximum idle connection count for reverse proxy.
swarm.modcluster.configuration-mod-cluster-config.socket-timeout: Timeout to wait for the reverse proxy to answer a MCMP message.
swarm.modcluster.configuration-mod-cluster-config.ssl-context: Reference to the SSLContext to be used by mod_cluster.
swarm.modcluster.configuration-mod-cluster-config.status-interval: Number of seconds a STATUS message is sent from the application server to the proxy.
swarm.modcluster.configuration-mod-cluster-config.sticky-session: Indicates whether subsequent requests for a given session should be routed to the same node, if possible.
swarm.modcluster.configuration-mod-cluster-config.sticky-session-force: Indicates whether the reverse proxy should return an error in the event that the balancer is unable to route a request to the node to which it is stuck. Ignored if sticky sessions are disabled.
swarm.modcluster.configuration-mod-cluster-config.sticky-session-remove: Indicates whether the reverse proxy should remove session stickiness in the event that the balancer is unable to route a request to the node to which it is stuck. Ignored if sticky sessions are disabled.
swarm.modcluster.configuration-mod-cluster-config.stop-context-timeout: Maximum time to wait for context to process pending requests.
swarm.modcluster.configuration-mod-cluster-config.ttl: Time to live (in seconds) for idle connections above smax.
swarm.modcluster.configuration-mod-cluster-config.worker-timeout: Number of seconds to wait for a worker to become available to handle a request.
swarm.modcluster.multicast-address: Multicast address
swarm.modcluster.multicast-port: Multicast port

6.44. MongoDB

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>mongodb</artifactId>
</dependency>

Configuration

swarm.mongo-db.mongos.KEY.auth-type: MongoDB authorization type
swarm.mongo-db.mongos.KEY.database: MongoDB database name
swarm.mongo-db.mongos.KEY.hosts.KEY.outbound-socket-binding-ref: MongoDB target hostname/port number
swarm.mongo-db.mongos.KEY.id: Unique profile identification
swarm.mongo-db.mongos.KEY.jndi-name: JNDI address
swarm.mongo-db.mongos.KEY.module: Module name
swarm.mongo-db.mongos.KEY.properties.KEY.property: Custom MongoDB property
swarm.mongo-db.mongos.KEY.security-domain: Security domain name
swarm.mongo-db.mongos.KEY.ssl: use SSL for connecting to MongoDB

6.45. Monitor

Warning

This fraction is deprecated. Use the io.thorntail:microprofile-health fraction instead.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>monitor</artifactId>
</dependency>

Configuration

swarm.monitor.security-realm: (not yet documented)

6.46. MSC

Primarily an internal fraction providing support for the JBoss Modular Container (MSC). JBoss MSC provides the underpinning for all services wired together supporting the container and the application.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>msc</artifactId>
</dependency>

6.47. MVC

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>mvc</artifactId>
</dependency>

6.48. Naming

Provides support for JNDI.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>naming</artifactId>
</dependency>

Configuration

swarm.naming.bindings.KEY.attribute-class: The object factory class name for object factory bindings
swarm.naming.bindings.KEY.binding-type: The type of binding to create, may be simple, lookup, external-context or object-factory
swarm.naming.bindings.KEY.cache: If the external context should be cached
swarm.naming.bindings.KEY.environment: The environment to use on object factory instance retrieval
swarm.naming.bindings.KEY.lookup: The entry to lookup in JNDI for lookup bindings
swarm.naming.bindings.KEY.module: The module to load the object factory from for object factory bindings
swarm.naming.bindings.KEY.type: The type of the value to bind for simple bindings, this must be a primitive type
swarm.naming.bindings.KEY.value: The value to bind for simple bindings

6.49. Neo4j

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>neo4j</artifactId>
</dependency>

Configuration

swarm.neo4j.neo4js.KEY.hosts.KEY.outbound-socket-binding-ref: Neo4J target hostname/port number
swarm.neo4j.neo4js.KEY.id: Unique profile identification
swarm.neo4j.neo4js.KEY.jndi-name: JNDI address
swarm.neo4j.neo4js.KEY.module: Module name
swarm.neo4j.neo4js.KEY.security-domain: Security domain name
swarm.neo4j.neo4js.KEY.transaction: Transaction enlistment (none or 1pc)

6.50. Guava

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>netflix-guava</artifactId>
</dependency>

6.51. RX-Java

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>netflix-rxjava</artifactId>
</dependency>

6.52. RX-Netty

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>netflix-rxnetty</artifactId>
</dependency>

6.53. Teiid OData

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>odata</artifactId>
</dependency>

Configuration

thorntail.teiid.odata.context: (not yet documented)
thorntail.teiid.odata.role: (not yet documented)
thorntail.teiid.odata.secured: (not yet documented)

6.54. OpenTracing

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>opentracing</artifactId>
</dependency>

Configuration

thorntail.opentracing.servlet.skipPattern: The servlet skip pattern as a Java compilable Pattern. Optional. Ex.: /health-check

6.54.1. OpenTracing TracerResolver

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>opentracing-tracerresolver</artifactId>
</dependency>

6.55. OrientDB

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>orientdb</artifactId>
</dependency>

Configuration

swarm.orient-db.orients.KEY.database: Database name
swarm.orient-db.orients.KEY.hosts.KEY.outbound-socket-binding-ref: OrientDB target hostname/port
swarm.orient-db.orients.KEY.id: Unique profile identification
swarm.orient-db.orients.KEY.jndi-name: Database JNDI address
swarm.orient-db.orients.KEY.max-partition-size: Max database pool partition size
swarm.orient-db.orients.KEY.max-pool-size: Max database pool size
swarm.orient-db.orients.KEY.module: Module name
swarm.orient-db.orients.KEY.remote: if true, Database is remote, if false, database is local (PLOCAL).
swarm.orient-db.orients.KEY.security-domain: Security domain name

6.56. Remoting

Primarily an internal fraction providing remote invocation support for higher-level fractions such as EJB.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>remoting</artifactId>
</dependency>

Configuration

swarm.remoting.connectors.KEY.authentication-provider: The "authentication-provider" element contains the name of the authentication provider to use for incoming connections.
swarm.remoting.connectors.KEY.properties.KEY.value: The property value.
swarm.remoting.connectors.KEY.sasl-authentication-factory: Reference to the SASL authentication factory to secure this connector.
swarm.remoting.connectors.KEY.sasl-protocol: The protocol to pass into the SASL mechanisms used for authentication.
swarm.remoting.connectors.KEY.sasl-security.include-mechanisms: The optional nested "include-mechanisms" element contains a whitelist of allowed SASL mechanism names. No mechanisms will be allowed which are not present in this list.
swarm.remoting.connectors.KEY.sasl-security.policy-sasl-policy.forward-secrecy: The optional nested "forward-secrecy" element contains a boolean value which specifies whether mechanisms that implement forward secrecy between sessions are required. Forward secrecy means that breaking into one session will not automatically provide information for breaking into future sessions.
swarm.remoting.connectors.KEY.sasl-security.policy-sasl-policy.no-active: The optional nested "no-active" element contains a boolean value which specifies whether mechanisms susceptible to active (non-dictionary) attacks are not permitted. "false" to permit, "true" to deny.
swarm.remoting.connectors.KEY.sasl-security.policy-sasl-policy.no-anonymous: The optional nested "no-anonymous" element contains a boolean value which specifies whether mechanisms that accept anonymous login are permitted. "false" to permit, "true" to deny.
swarm.remoting.connectors.KEY.sasl-security.policy-sasl-policy.no-dictionary: The optional nested "no-dictionary" element contains a boolean value which specifies whether mechanisms susceptible to passive dictionary attacks are permitted. "false" to permit, "true" to deny.
swarm.remoting.connectors.KEY.sasl-security.policy-sasl-policy.no-plain-text: The optional nested "no-plain-text" element contains a boolean value which specifies whether mechanisms susceptible to simple plain passive attacks (e.g., "PLAIN") are not permitted. "false" to permit, "true" to deny.
swarm.remoting.connectors.KEY.sasl-security.policy-sasl-policy.pass-credentials: The optional nested "pass-credentials" element contains a boolean value which specifies whether mechanisms that pass client credentials are required.
swarm.remoting.connectors.KEY.sasl-security.properties.KEY.value: The property value.
swarm.remoting.connectors.KEY.sasl-security.qop: The optional nested "qop" element contains a list of quality-of-protection values, in decreasing order of preference.
swarm.remoting.connectors.KEY.sasl-security.reuse-session: The optional nested "reuse-session" boolean element specifies whether or not the server should attempt to reuse previously authenticated session information. The mechanism may or may not support such reuse, and other factors may also prevent it.
swarm.remoting.connectors.KEY.sasl-security.server-auth: The optional nested "server-auth" boolean element specifies whether the server should authenticate to the client. Not all mechanisms may support this setting.
swarm.remoting.connectors.KEY.sasl-security.strength: The optional nested "strength" element contains a list of cipher strength values, in decreasing order of preference.
swarm.remoting.connectors.KEY.security-realm: The associated security realm to use for authentication for this connector.
swarm.remoting.connectors.KEY.server-name: The server name to send in the initial message exchange and for SASL based authentication.
swarm.remoting.connectors.KEY.socket-binding: The name of the socket binding to attach to.
swarm.remoting.connectors.KEY.ssl-context: Reference to the SSLContext to use for this connector.
swarm.remoting.endpoint-configuration.auth-realm: The authentication realm to use if no authentication {@code CallbackHandler} is specified.
swarm.remoting.endpoint-configuration.authentication-retries: Specify the number of times a client is allowed to retry authentication before closing the connection.
swarm.remoting.endpoint-configuration.authorize-id: The SASL authorization ID. Used as authentication user name to use if no authentication {@code CallbackHandler} is specifiedand the selected SASL mechanism demands a user name.
swarm.remoting.endpoint-configuration.buffer-region-size: The size of allocated buffer regions.
swarm.remoting.endpoint-configuration.heartbeat-interval: The interval to use for connection heartbeat, in milliseconds. If the connection is idle in the outbound directionfor this amount of time, a ping message will be sent, which will trigger a corresponding reply message.
swarm.remoting.endpoint-configuration.max-inbound-channels: The maximum number of inbound channels to support for a connection.
swarm.remoting.endpoint-configuration.max-inbound-message-size: The maximum inbound message size to be allowed. Messages exceeding this size will cause an exception to be thrown on the reading side as well as the writing side.
swarm.remoting.endpoint-configuration.max-inbound-messages: The maximum number of concurrent inbound messages on a channel.
swarm.remoting.endpoint-configuration.max-outbound-channels: The maximum number of outbound channels to support for a connection.
swarm.remoting.endpoint-configuration.max-outbound-message-size: The maximum outbound message size to send. No messages larger than this well be transmitted; attempting to do so will cause an exception on the writing side.
swarm.remoting.endpoint-configuration.max-outbound-messages: The maximum number of concurrent outbound messages on a channel.
swarm.remoting.endpoint-configuration.receive-buffer-size: The size of the largest buffer that this endpoint will accept over a connection.
swarm.remoting.endpoint-configuration.receive-window-size: The maximum window size of the receive direction for connection channels, in bytes.
swarm.remoting.endpoint-configuration.sasl-protocol: Where a SaslServer or SaslClient are created by default the protocol specified it 'remoting', this can be used to override this.
swarm.remoting.endpoint-configuration.send-buffer-size: The size of the largest buffer that this endpoint will transmit over a connection.
swarm.remoting.endpoint-configuration.server-name: The server side of the connection passes it’s name to the client in the initial greeting, by default the name is automatically discovered from the local address of the connection or it can be overridden using this.
swarm.remoting.endpoint-configuration.transmit-window-size: The maximum window size of the transmit direction for connection channels, in bytes.
swarm.remoting.endpoint-configuration.worker: Worker to use
swarm.remoting.http-connectors.KEY.authentication-provider: The "authentication-provider" element contains the name of the authentication provider to use for incoming connections.
swarm.remoting.http-connectors.KEY.connector-ref: The name (or names) of a connector in the Undertow subsystem to connect to.
swarm.remoting.http-connectors.KEY.properties.KEY.value: The property value.
swarm.remoting.http-connectors.KEY.sasl-authentication-factory: Reference to the SASL authentication factory to use for this connector.
swarm.remoting.http-connectors.KEY.sasl-protocol: The protocol to pass into the SASL mechanisms used for authentication.
swarm.remoting.http-connectors.KEY.sasl-security.include-mechanisms: The optional nested "include-mechanisms" element contains a whitelist of allowed SASL mechanism names. No mechanisms will be allowed which are not present in this list.
swarm.remoting.http-connectors.KEY.sasl-security.policy-sasl-policy.forward-secrecy: The optional nested "forward-secrecy" element contains a boolean value which specifies whether mechanisms that implement forward secrecy between sessions are required. Forward secrecy means that breaking into one session will not automatically provide information for breaking into future sessions.
swarm.remoting.http-connectors.KEY.sasl-security.policy-sasl-policy.no-active: The optional nested "no-active" element contains a boolean value which specifies whether mechanisms susceptible to active (non-dictionary) attacks are not permitted. "false" to permit, "true" to deny.
swarm.remoting.http-connectors.KEY.sasl-security.policy-sasl-policy.no-anonymous: The optional nested "no-anonymous" element contains a boolean value which specifies whether mechanisms that accept anonymous login are permitted. "false" to permit, "true" to deny.
swarm.remoting.http-connectors.KEY.sasl-security.policy-sasl-policy.no-dictionary: The optional nested "no-dictionary" element contains a boolean value which specifies whether mechanisms susceptible to passive dictionary attacks are permitted. "false" to permit, "true" to deny.
swarm.remoting.http-connectors.KEY.sasl-security.policy-sasl-policy.no-plain-text: The optional nested "no-plain-text" element contains a boolean value which specifies whether mechanisms susceptible to simple plain passive attacks (e.g., "PLAIN") are not permitted. "false" to permit, "true" to deny.
swarm.remoting.http-connectors.KEY.sasl-security.policy-sasl-policy.pass-credentials: The optional nested "pass-credentials" element contains a boolean value which specifies whether mechanisms that pass client credentials are required.
swarm.remoting.http-connectors.KEY.sasl-security.properties.KEY.value: The property value.
swarm.remoting.http-connectors.KEY.sasl-security.qop: The optional nested "qop" element contains a list of quality-of-protection values, in decreasing order of preference.
swarm.remoting.http-connectors.KEY.sasl-security.reuse-session: The optional nested "reuse-session" boolean element specifies whether or not the server should attempt to reuse previously authenticated session information. The mechanism may or may not support such reuse, and other factors may also prevent it.
swarm.remoting.http-connectors.KEY.sasl-security.server-auth: The optional nested "server-auth" boolean element specifies whether the server should authenticate to the client. Not all mechanisms may support this setting.
swarm.remoting.http-connectors.KEY.sasl-security.strength: The optional nested "strength" element contains a list of cipher strength values, in decreasing order of preference.
swarm.remoting.http-connectors.KEY.security-realm: The associated security realm to use for authentication for this connector.
swarm.remoting.http-connectors.KEY.server-name: The server name to send in the initial message exchange and for SASL based authentication.
swarm.remoting.local-outbound-connections.KEY.outbound-socket-binding-ref: Name of the outbound-socket-binding which will be used to determine the destination address and port for the connection.
swarm.remoting.local-outbound-connections.KEY.properties.KEY.value: The property value.
swarm.remoting.outbound-connections.KEY.properties.KEY.value: The property value.
swarm.remoting.outbound-connections.KEY.uri: The connection URI for the outbound connection.
swarm.remoting.port: Port for legacy remoting connector
swarm.remoting.remote-outbound-connections.KEY.authentication-context: Reference to the authentication context instance containing the configuration for outbound connections.
swarm.remoting.remote-outbound-connections.KEY.outbound-socket-binding-ref: Name of the outbound-socket-binding which will be used to determine the destination address and port for the connection.
swarm.remoting.remote-outbound-connections.KEY.properties.KEY.value: The property value.
swarm.remoting.remote-outbound-connections.KEY.protocol: The protocol to use for the remote connection.
swarm.remoting.remote-outbound-connections.KEY.security-realm: Reference to the security realm to use to obtain the password and SSL configuration.
swarm.remoting.remote-outbound-connections.KEY.username: The user name to use when authenticating against the remote server.
swarm.remoting.required: (not yet documented)
swarm.remoting.worker-read-threads: The number of read threads to create for the remoting worker.
swarm.remoting.worker-task-core-threads: The number of core threads for the remoting worker task thread pool.
swarm.remoting.worker-task-keepalive: The number of milliseconds to keep non-core remoting worker task threads alive.
swarm.remoting.worker-task-limit: The maximum number of remoting worker tasks to allow before rejecting.
swarm.remoting.worker-task-max-threads: The maximum number of threads for the remoting worker task thread pool.
swarm.remoting.worker-write-threads: The number of write threads to create for the remoting worker.

6.57. Request Controller

Provides support for the WildFly request-controller, allowing for graceful pause/resume/shutdown of the container.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>request-controller</artifactId>
</dependency>

Configuration

swarm.request-controller.active-requests: The number of requests that are currently running in the server
swarm.request-controller.max-requests: The maximum number of all types of requests that can be running in a server at a time. Once this limit is hit any new requests will be rejected.
swarm.request-controller.track-individual-endpoints: If this is true requests are tracked at an endpoint level, which will allow individual deployments to be suspended

6.58. Resource Adapters

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>resource-adapters</artifactId>
</dependency>

Configuration

thorntail.resource-adapters.resource-adapters.KEY.admin-objects.KEY.class-name: Specifies the fully qualified class name of an administration object.
thorntail.resource-adapters.resource-adapters.KEY.admin-objects.KEY.config-properties.KEY.value: Custom defined config property value.
thorntail.resource-adapters.resource-adapters.KEY.admin-objects.KEY.enabled: Specifies if the administration object should be enabled.
thorntail.resource-adapters.resource-adapters.KEY.admin-objects.KEY.jndi-name: Specifies the JNDI name for the administration object.
thorntail.resource-adapters.resource-adapters.KEY.admin-objects.KEY.use-java-context: Setting this to false will bind the object into global JNDI.
thorntail.resource-adapters.resource-adapters.KEY.archive: Specifies the resource adapter archive.
thorntail.resource-adapters.resource-adapters.KEY.beanvalidationgroups: Specifies the bean validation groups that should be used.
thorntail.resource-adapters.resource-adapters.KEY.bootstrap-context: Specifies the unique name of the bootstrap context that should be used.
thorntail.resource-adapters.resource-adapters.KEY.config-properties.KEY.value: Custom defined config property value.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.allocation-retry: The allocation retry element indicates the number of times that allocating a connection should be tried before throwing an exception.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.allocation-retry-wait-millis: The allocation retry wait millis element specifies the amount of time, in milliseconds, to wait between retrying to allocate a connection.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.authentication-context: The Elytron authentication context which defines the javax.security.auth.Subject that is used to distinguish connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.authentication-context-and-application: Indicates that either application-supplied parameters, such as from getConnection(user, pw), or Subject (provided by Elytron after authenticating using configured authentication-context), are used to distinguish connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.background-validation: An element to specify that connections should be validated on a background thread versus being validated prior to use. Changing this value requires a server restart.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.background-validation-millis: The background-validation-millis element specifies the amount of time, in milliseconds, that background validation will run. Changing this value requires a server restart.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.blocking-timeout-wait-millis: The blocking-timeout-millis element specifies the maximum time, in milliseconds, to block while waiting for a connection before throwing an exception. Note that this blocks only while waiting for locking a connection, and will never throw an exception if creating a new connection takes an inordinately long time.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.capacity-decrementer-class: Class defining the policy for decrementing connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.capacity-decrementer-properties: Properties to inject in class defining the policy for decrementing connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.capacity-incrementer-class: Class defining the policy for incrementing connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.capacity-incrementer-properties: Properties to inject in class defining the policy for incrementing connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.class-name: Specifies the fully qualified class name of a managed connection factory or admin object.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.config-properties.KEY.value: Custom defined config property value.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.connectable: Enable the use of CMR. This feature means that a local resource can reliably participate in an XA transaction.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.elytron-enabled: Enables Elytron security for handling authentication of connections. The Elytron authentication-context to be used will be current context if no context is specified (see authentication-context).
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.enabled: Specifies if the resource adapter should be enabled.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.enlistment: Defines if lazy enlistment should be used if supported by the resource adapter.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.enlistment-trace: Defines if WildFly/IronJacamar should record enlistment traces.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.flush-strategy: Specifies how the pool should be flushed in case of an error.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.idle-timeout-minutes: Specifies the maximum time, in minutes, a connection may be idle before being closed. The actual maximum time depends also on the IdleRemover scan time, which is half of the smallest idle-timeout-minutes value of any pool. Changing this value requires a server restart.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.initial-pool-size: Specifies the initial number of connections a pool should hold.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.interleaving: An element to enable interleaving for XA connections.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.jndi-name: Specifies the JNDI name for the connection factory.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.max-pool-size: Specifies the maximum number of connections for a pool. No more connections will be created in each sub-pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.mcp: Defines the ManagedConnectionPool implementation. For example: org.jboss.jca.core.connectionmanager.pool.mcp.SemaphoreArrayListManagedConnectionPool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.min-pool-size: Specifies the minimum number of connections for a pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.no-recovery: Specifies if the connection pool should be excluded from recovery.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.no-tx-separate-pool: Oracle does not like XA connections getting used both inside and outside a JTA transaction. To workaround the problem you can create separate sub-pools for the different contexts.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.pad-xid: Specifies whether the Xid should be padded.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.pool-fair: Defines if pool use should be fair.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.pool-prefill: Specifies if the pool should be prefilled. Changing this value requires a server restart.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.pool-use-strict-min: Specifies if the min-pool-size should be considered strict.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-authentication-context: The Elytron authentication context used for recovery (current authentication-context will be used if unspecified).
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-credential-reference: Credential (from Credential Store) to authenticate on recovery connection
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-elytron-enabled: Indicates that an Elytron authentication context will be used for recovery.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-password: The password used for recovery.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-plugin-class-name: The fully qualified class name of the recovery plugin implementation.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-plugin-properties: The properties for the recovery plugin.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-security-domain: The PicketBox security domain used for recovery.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.recovery-username: The user name used for recovery.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.same-rm-override: Using this attribute, you can unconditionally set whether javax.transaction.xa.XAResource.isSameRM(XAResource) returns true or false.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.security-application: Indicates that application-supplied parameters, such as from getConnection(user, pw), are used to distinguish connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.security-domain: Specifies the PicketBox security domain which defines the javax.security.auth.Subject that is used to distinguish connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.security-domain-and-application: Indicates that either application-supplied parameters, such as from getConnection(user, pw), or Subject (from PicketBox security domain), are used to distinguish connections in the pool.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.sharable: Enable the use of sharable connections, which allows lazy association to be enabled if supported.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.tracking: Defines if IronJacamar should track connection handles across transaction boundaries.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.use-ccm: Enable the use of a cached connection manager.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.use-fast-fail: Whether to fail a connection allocation on the first try if it is invalid (true) or keep trying until the pool is exhausted of all potential connections (false).
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.use-java-context: Setting this to false will bind the object into global JNDI.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.validate-on-match: This specifies if connection validation should be done when a connection factory attempts to match a managed connection. This is typically exclusive to the use of background validation.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.wrap-xa-resource: Specifies whether XAResource instances should be wrapped in an org.jboss.tm.XAResourceWrapper instance.
thorntail.resource-adapters.resource-adapters.KEY.connection-definitions.KEY.xa-resource-timeout: The value is passed to XAResource.setTransactionTimeout(), in seconds.
thorntail.resource-adapters.resource-adapters.KEY.module: Specifies the module from which resource adapter will be loaded
thorntail.resource-adapters.resource-adapters.KEY.statistics-enabled: Define whether runtime statistics are enabled or not.
thorntail.resource-adapters.resource-adapters.KEY.transaction-support: Specifies the transaction support level of the resource adapter.
thorntail.resource-adapters.resource-adapters.KEY.wm-elytron-security-domain: Defines the name of the Elytron security domain that should be used.
thorntail.resource-adapters.resource-adapters.KEY.wm-security: Toggle on/off wm.security for this resource adapter. In case of false all wm-security-* parameters are ignored, even the defaults.
thorntail.resource-adapters.resource-adapters.KEY.wm-security-default-groups: Defines a default groups list that should be added to the used Subject instance.
thorntail.resource-adapters.resource-adapters.KEY.wm-security-default-principal: Defines a default principal name that should be added to the used Subject instance.
thorntail.resource-adapters.resource-adapters.KEY.wm-security-domain: Defines the name of the PicketBox security domain that should be used.
thorntail.resource-adapters.resource-adapters.KEY.wm-security-mapping-groups: List of groups mappings.
thorntail.resource-adapters.resource-adapters.KEY.wm-security-mapping-required: Defines if a mapping is required for security credentials.
thorntail.resource-adapters.resource-adapters.KEY.wm-security-mapping-users: List of user mappings.

6.59. Ribbon

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>ribbon</artifactId>
</dependency>

Configuration

thorntail.deployment.KEY.ribbon.advertise: (not yet documented)

6.59.1. Ribbon Secured

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>ribbon-secured</artifactId>
</dependency>

Ribbon Secured Client

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>ribbon-secured-client</artifactId>
</dependency>

6.60. Deployment Scanner

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>scanner</artifactId>
</dependency>

6.61. Security

Provides underlying security infrastructure to support JAAS and other security APIs.

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>security</artifactId>
</dependency>

Configuration

swarm.security.classic-vault.code: Fully Qualified Name of the Security Vault Implementation.
swarm.security.classic-vault.vault-options: Security Vault options.
swarm.security.deep-copy-subject-mode: Sets the copy mode of subjects done by the security managers to be deep copies that makes copies of the subject principals and credentials if they are cloneable. It should be set to true if subject include mutable content that can be corrupted when multiple threads have the same identity and cache flushes/logout clearing the subject in one thread results in subject references affecting other threads.
swarm.security.elytron-key-managers.KEY.legacy-jsse-config: The name of the legacy security domain that contains a JSSE configuration that can be used to export the key manager.
swarm.security.elytron-key-stores.KEY.legacy-jsse-config: The name of the legacy security domain that contains a JSSE configuration that can be used to export the key store.
swarm.security.elytron-realms.KEY.apply-role-mappers: Indicates to the realm if it should apply the role mappers defined in the legacy domain to the roles obtained from authenticated Subjects or not.
swarm.security.elytron-realms.KEY.legacy-jaas-config: The name of the legacy security domain to which authentication will be delegated.
swarm.security.elytron-trust-managers.KEY.legacy-jsse-config: The name of the legacy security domain that contains a JSSE configuration that can be used to export the trust manager.
swarm.security.elytron-trust-stores.KEY.legacy-jsse-config: The name of the legacy security domain that contains a JSSE configuration that can be used to export the trust store.
swarm.security.initialize-jacc: Indicates if this subsystem should be in charge of initializing JACC related services.
swarm.security.security-domains.KEY.cache-type: Adds a cache to speed up authentication checks. Allowed values are 'default' to use simple map as the cache and 'infinispan' to use an Infinispan cache.
swarm.security.security-domains.KEY.classic-acl.acl-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.classic-acl.acl-modules.KEY.flag: The flag controls how the module participates in the overall procedure. Allowed values are requisite, required, sufficient or optional.
swarm.security.security-domains.KEY.classic-acl.acl-modules.KEY.module: Name of JBoss Module where the login module is located.
swarm.security.security-domains.KEY.classic-acl.acl-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.classic-audit.provider-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.classic-audit.provider-modules.KEY.module: Name of JBoss Module where the mapping module code is located.
swarm.security.security-domains.KEY.classic-audit.provider-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.classic-authentication.login-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.classic-authentication.login-modules.KEY.flag: The flag controls how the module participates in the overall procedure. Allowed values are requisite, required, sufficient or optional.
swarm.security.security-domains.KEY.classic-authentication.login-modules.KEY.module: Name of JBoss Module where the login module is located.
swarm.security.security-domains.KEY.classic-authentication.login-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.classic-authorization.policy-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.classic-authorization.policy-modules.KEY.flag: The flag controls how the module participates in the overall procedure. Allowed values are requisite, required, sufficient or optional.
swarm.security.security-domains.KEY.classic-authorization.policy-modules.KEY.module: Name of JBoss Module where the login module is located.
swarm.security.security-domains.KEY.classic-authorization.policy-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.classic-identity-trust.trust-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.classic-identity-trust.trust-modules.KEY.flag: The flag controls how the module participates in the overall procedure. Allowed values are requisite, required, sufficient or optional.
swarm.security.security-domains.KEY.classic-identity-trust.trust-modules.KEY.module: Name of JBoss Module where the login module is located.
swarm.security.security-domains.KEY.classic-identity-trust.trust-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.classic-jsse.additional-properties: Additional properties that may be necessary to configure JSSE.
swarm.security.security-domains.KEY.classic-jsse.cipher-suites: Comma separated list of cipher suites to enable on SSLSockets.
swarm.security.security-domains.KEY.classic-jsse.client-alias: Preferred alias to use when the KeyManager chooses the client alias.
swarm.security.security-domains.KEY.classic-jsse.client-auth: Boolean attribute to indicate if client’s certificates should also be authenticated on the server side.
swarm.security.security-domains.KEY.classic-jsse.key-manager: JSEE Key Manager factory
swarm.security.security-domains.KEY.classic-jsse.keystore: Configures a JSSE key store
swarm.security.security-domains.KEY.classic-jsse.protocols: Comma separated list of protocols to enable on SSLSockets.
swarm.security.security-domains.KEY.classic-jsse.server-alias: Preferred alias to use when the KeyManager chooses the server alias.
swarm.security.security-domains.KEY.classic-jsse.service-auth-token: Token to retrieve PrivateKeys from the KeyStore.
swarm.security.security-domains.KEY.classic-jsse.trust-manager: JSEE Trust Manager factory
swarm.security.security-domains.KEY.classic-jsse.truststore: Configures a JSSE trust store
swarm.security.security-domains.KEY.classic-mapping.mapping-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.classic-mapping.mapping-modules.KEY.module: Name of JBoss Module where the mapping module code is located.
swarm.security.security-domains.KEY.classic-mapping.mapping-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.classic-mapping.mapping-modules.KEY.type: Type of mapping this module performs. Allowed values are principal, role, attribute or credential..
swarm.security.security-domains.KEY.jaspi-authentication.auth-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.jaspi-authentication.auth-modules.KEY.flag: The flag controls how the module participates in the overall procedure. Allowed values are requisite, required, sufficient or optional.
swarm.security.security-domains.KEY.jaspi-authentication.auth-modules.KEY.login-module-stack-ref: Reference to a login module stack name previously configured in the same security domain.
swarm.security.security-domains.KEY.jaspi-authentication.auth-modules.KEY.module: Name of JBoss Module where the mapping module code is located.
swarm.security.security-domains.KEY.jaspi-authentication.auth-modules.KEY.module-options: List of module options containing a name/value pair.
swarm.security.security-domains.KEY.jaspi-authentication.login-module-stacks.KEY.login-modules.KEY.code: Class name of the module to be instantiated.
swarm.security.security-domains.KEY.jaspi-authentication.login-module-stacks.KEY.login-modules.KEY.flag: The flag controls how the module participates in the overall procedure. Allowed values are requisite, required, sufficient or optional.
swarm.security.security-domains.KEY.jaspi-authentication.login-module-stacks.KEY.login-modules.KEY.module: Name of JBoss Module where the login module is located.
swarm.security.security-domains.KEY.jaspi-authentication.login-module-stacks.KEY.login-modules.KEY.module-options: List of module options containing a name/value pair.

6.62. Servo

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>servo</artifactId>
</dependency>

6.63. Spring WebMVC

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>spring</artifactId>
</dependency>

6.64. Swagger

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>swagger</artifactId>
</dependency>

Configuration

thorntail.deployment.KEY.swagger.description: (not yet documented)
thorntail.deployment.KEY.swagger.host: (not yet documented)
thorntail.deployment.KEY.swagger.license: (not yet documented)
thorntail.deployment.KEY.swagger.license-url: (not yet documented)
thorntail.deployment.KEY.swagger.packages: (not yet documented)
thorntail.deployment.KEY.swagger.root: (not yet documented)
thorntail.deployment.KEY.swagger.schemes: (not yet documented)
thorntail.deployment.KEY.swagger.title: (not yet documented)
thorntail.deployment.KEY.swagger.tos-url: (not yet documented)
thorntail.deployment.KEY.swagger.version: (not yet documented)

6.64.1. Swagger Webapp

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>swagger-webapp</artifactId>
</dependency>

Configuration

thorntail.swagger.web-app.context: Web context path for Swagger end point
thorntail.swagger.web-app.web-content: (not yet documented)

6.65. Teiid Fraction

Maven Coordinates

<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>teiid</artifactId>
</dependency>

Configuration

swarm.teiid.active-session-count: Number of active sessions in the system
swarm.teiid.allow-env-function: Allow the execution of ENV function. (default false)
swarm.teiid.async-thread-pool-max-thread-count: Maximum number of threads for asynchronous processing
swarm.teiid.authentication-allow-security-domain-qualifier: Allow user names to be qualified with @security-domain.
swarm.teiid.authentication-max-sessions-allowed: Maximum number of sessions allowed by the system (default 10000)
swarm.teiid.authentication-security-domain: Security domain to be enforced with the transport
swarm.teiid.authentication-sessions-expiration-timelimit

Thorntail Documentation

Concepts

1. Fractions

2. Packaging Types

2.1. Uberjar

2.2. Hollow JAR

2.2.1. Pre-Built Hollow JARs

HOWTO

3. Basics

3.1. Creating an application from scratch

Prerequisites

Procedure

Results

3.2. Using a BOM

3.2.1. Thorntail community BOM types

3.2.2. Specifying a BOM for in your application

3.3. Creating an uberjar

Prerequisites

Procedure

3.4. Creating a hollow JAR

Prerequisites

Procedure

Related information

3.5. Auto-detecting fractions

Prerequisites

Procedure

3.6. Using explicit fractions

3.7. Creating a datasource

3.7.1. Configuring a JDBC driver

Auto-detecting JDBC drivers

Prerequisites

Procedure

Configuring the JDBC driver manually

Prerequisites

Procedure

3.7.2. Configuring a datasource

Prerequisites

Procedure

3.7.3. Example full project-defaults.yml file

3.8. Testing in a container

Prerequisites

Procedure

3.9. Logging

3.9.1. Enabling logging

3.9.2. Logging to a file

Prerequisites

Procedure

3.10. Distributed tracing

3.10.1. What is distributed tracing

3.10.2. Tracing a single service

3.10.3. Tracing a complex service

3.11. Metrics

3.11.1. What are metrics

3.11.2. Exposing metrics

4. Advanced

4.1. How to Create a Fraction

4.1.1. Introduction

4.1.2. The pom.xml

4.1.3. What’s in a Fraction

Package Layout

The module.conf

The *Fraction.java

Runtime CDI Components

DeploymentProcessor

Customizer

Archive producers

@Configurable and Defaultable<>

Auto-detection

Transitive dependencies

Logging

Reference

5. General

5.1. Using Thorntail Maven Plugin

5.1.1. Thorntail Maven plugin general usage

5.1.2. Thorntail Maven plugin goals

5.1.3. Thorntail Maven plugin configuration options

5.1.4. Thorntail Maven plugin configuration properties

5.2. Configuring a Thorntail application

5.2.1. System properties

Commonly used system properties

4.1.2. The `pom.xml`

The `module.conf`

The `*Fraction.java`

`DeploymentProcessor`

`Customizer`

`Archive` producers

`@Configurable` and `Defaultable<>`