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

For more information, see the WildFly Swarm home page.

Concepts

1. Fractions

WildFly Swarm 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 WildFly Swarm 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 WildFly Swarm fractions, a bill of materials (BOM) is available. For more information, see Using a BOM.

2. Packaging Types (Uberjars & Hollow Jars)

When using WildFly Swarm, there are two different 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 to 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 WildFly Swarm produces include the name of your application and the -swarm.jar suffix.

An uberjar can be executed like any executable JAR:

$ java -jar myapp-swarm.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 WildFly Swarm produces include the name of your application, and the -hollow-swarm.jar suffix. You must package the .war file of your application separately in order to benefit from the hollow JAR.

Provide the application .war file as an argument to the Java binary when executing the hollow JAR:

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

HOWTO

3. Basics

3.1. Using a BOM

To explicitly specify the WildFly Swarm fractions your application uses, instead of relying on auto-detection, WildFly Swarm 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.1.1. Different types of BOMs

WildFly Swarm is described as just enough app-server, which means it comprises 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. To help separate the stable pieces from the less stable ones, the following Maven BOMs can be used:

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.

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

Procedure
  1. Include a bom artifact in your pom.xml.

    Tracking the current version of WildFly Swarm through a property in your pom.xml is recommended.

    <properties>
      <version.wildfly-swarm>2017.11.0</version.wildfly-swarm>
    </properties>

    Import BOMs in the <dependencyManagement> section. Specify the <type>pom</type> and <scope>import</scope>.

    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>org.wildfly.swarm</groupId>
          <artifactId>bom</artifactId>
          <version>${version.wildfly-swarm}</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>org.wildfly.swarm</groupId>
          <artifactId>bom</artifactId>
          <version>${version.wildfly-swarm}</version>
          <type>pom</type>
          <scope>import</scope>
        </dependency>
        <!--
        <dependency>
          <groupId>org.wildfly.swarm</groupId>
          <artifactId>bom-unstable</artifactId>
          <version>${version.wildfly-swarm}</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 WildFly Swarm 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.

  2. Include WildFly Swarm dependencies.

    Even though you imported the WildFly Swarm BOMs in the <dependencyManagement> section, your application still has no dependencies on WildFly Swarm artifacts.

    To include WildFly Swarm 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>org.wildfly.swarm</groupId>
        <artifactId>jaxrs</artifactId>
      </dependency>
      <dependency>
        <groupId>org.wildfly.swarm</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.1.2. Caveats

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 WildFly Swarm 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 WildFly Swarm that you are targeting with the BOM import.

<plugins>
  <plugin>
    <groupId>org.wildfly.swarm</groupId>
    <artifactId>wildfly-swarm-plugin</artifactId>
    <version>${version.wildfly-swarm}</version>
      ...
  </plugin>
</plugins>
Related Information

3.2. Creating an Uberjar

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

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

Procedure
  1. Add the wildfly-swarm-plugin to your pom.xml in a <plugin> block, with an <execution> specifying the package goal.

    <plugins>
      <plugin>
        <groupId>org.wildfly.swarm</groupId>
        <artifactId>wildfly-swarm-plugin</artifactId>
        <version>${version.wildfly-swarm}</version>
        <executions>
          <execution>
            <id>package</id>
            <goals>
              <goal>package</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  2. Perform a normal Maven build:

    $ mvn package
  3. Execute the resulting uberjar:

    $ java -jar ./target/myapp-swarm.jar
Related Information

3.3. Creating a hollow JAR

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

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

Procedure
  1. Add the wildfly-swarm-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>org.wildfly.swarm</groupId>
        <artifactId>wildfly-swarm-plugin</artifactId>
        <version>${version.wildfly-swarm}</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 -Dswarm.hollow=true instead. For more information, see the Maven plugin configuration reference.

  2. Perform a normal Maven build:

    $ mvn package
  3. Execute the hollow JAR:

    Execute the resulting -hollow-swarm.jar file using the Java binary and pass the .war file with your application as the first argument:

    $ java -jar ./target/myapp-hollow-swarm.jar ./target/myapp.war
Related Information

3.4. Auto-detecting fractions

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

Note
By default, WildFly Swarm 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>

WildFly Swarm then includes the jaxrs fraction during the build automatically.

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

Procedure
  1. Add the wildfly-swarm-plugin to your pom.xml in a <plugin> block, with an <execution> specifying the package goal.

    <plugins>
      <plugin>
        <groupId>org.wildfly.swarm</groupId>
        <artifactId>wildfly-swarm-plugin</artifactId>
        <version>${version.wildfly-swarm}</version>
        <executions>
          <execution>
            <id>package</id>
            <goals>
              <goal>package</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  2. Perform a normal Maven build:

    $ mvn package
  3. Execute the resulting uberjar:

    $ java -jar ./target/myapp-swarm.jar
Related Information

3.5. 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
  1. Add the BOM to your pom.xml. For more information, see Using a BOM.

  2. Add the WildFly Swarm Maven plugin to your pom.xml. For more information, see Creating an Uberjar.

  3. Add one or more dependencies on WildFly Swarm fractions to the pom.xml file:

    <dependencies>
      <dependency>
        <groupId>org.wildfly.swarm</groupId>
        <artifactId>jaxrs</artifactId>
      </dependency>
    </dependencies>
  4. Perform a normal Maven build:

    $ mvn package
  5. Execute the resulting uberjar:

    $ java -jar ./target/myapp-swarm.jar
Related Information

3.6. 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.6.1. Configuring a JDBC Driver

There are two options how to configure JDBC drivers:

Auto-detecting JDBC drivers

WildFly Swarm 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 WildFly Swarm auto-detects include:

  • H2

  • MySQL

  • PostgreSQL

  • EnterpriseDB

  • SQLServer

  • Oracle

  • Sybase

  • DB2

Prerequisites
  • A Maven-based application.

  • A database to connect to.

  • The Maven coordinates of the JDBC driver you want to use.

Procedure
  1. Add the appropriate dependency (with the default <scope>compile</scope> scope) to your application:

    <dependencies>
      <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>
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
  1. Edit the project-defaults.yml file to define the driver information.

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

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

3.6.2. Configuring a datasource

Prerequisites
  • A Maven-based application.

  • A JDBC Driver configured.

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

    swarm:
      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.6.3. Example full project-defaults.yml file

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

swarm:
  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.7. 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 WildFly Swarm that makes Arquillian-based testing work well with WildFly Swarm–based applications.

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

Procedure
  1. Include the WildFly Swarm BOM as described in Using a BOM. For example, bom-all:

    <dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>org.wildfly.swarm</groupId>
          <artifactId>bom</artifactId>
          <version>${version.wildfly-swarm}</version>
          <type>pom</type>
          <scope>import</scope>
        </dependency>
      </dependencies>
    </dependencyManagement>
  2. Reference the org.wildfly.swarm:arquillian artifact in your pom.xml file with the <scope> set to test:

    <dependencies>
      <dependency>
        <groupId>org.wildfly.swarm</groupId>
        <artifactId>arquillian</artifactId>
        <scope>test</scope>
      </dependency>
    </dependencies>
  3. Create your Application.

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

    swarm:
      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
  4. Create a test class.

    Note
    Creating an Arquillian test before WildFly Swarm 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 {
    }
  5. 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 WildFly Swarm 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;
  6. 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 );
    }
  7. 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.
Related Information

4. Advanced

4.1. How to Create a Fraction

4.1.1. Introduction

The composable pieces of WildFly Swarm 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 WildFly Swarm SPI and fraction-plugin being used:

<properties>
  <version.swarm>2017.11.0</version.swarm.spi>
  <version.swarm.fraction-plugin>34</version.swarm.fraction-plugin>
</properties>

You can include all of the primary bits of WildFly Swarm 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>org.wildfly.swarm</groupId>
      <artifactId>bom-all</artifactId>
      <version>${version.swarm}</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 wildfly-swarm-fraction-plugin should be configured within the parent pom.xml so that it fires for every sub-module:

<build>
  <plugins>
    <plugin>
      <groupId>org.wildfly.swarm</groupId>
      <artifactId>wildfly-swarm-fraction-plugin</artifactId>
      <version>${version.swarm.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 may be two (or more) additional sub-packages, named 'runtime' and 'deployment'.

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 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 alters 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. They should each be marked as @ApplicationScoped.

@ApplicationScoped
public class MyComponents implements Whatever {

  @Inject
  private MyFraction myFraction;

}
ArchivePreparer

If your fraction needs an opportunity to alter or otherwise prepare all deployed archives, you may implement the org.wildfly.swarm.spi.api.ArchivePreparer interface.

@ApplicationScoped
public class MyArchivePreparer implements ArchivePreparer {

  @Inject
  private MyFraction myFraction;

  public void prepareArchive(Archive<?> archive) {
    archive.as( WARArchive.class ).setContextRoot( myFraction.getContextRoot() );
  }
}
ArchiveMetadataProcessor

If your fraction needs an opportunity to process the Jandex metadata of all deployed archives, you may implement the org.wildfly.swarm.spi.api.ArchiveMetadataProcessor interface.

@ApplicationScoped
public class MyArchiveMetadataProcessor implements ArchiveMetadataProcessor {

  @Inject
  private MyFraction myFraction;

  public void processArchive(Archive<?> archive, Index index) {
    // ...
  }
}
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 org.wildfly.swarm: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("swarm.myfraction.taco")
@AttributeDefinite("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("swarm.myfraction.taco")
@AttributeDefinite("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 WildFly Swarm 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 WildFly Swarm 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>org.wildfly.swarm</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. Maven Plugin

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

General Usage

The WildFly Swarm 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>org.wildfly.swarm</groupId>
  <artifactId>wildfly-swarm-plugin</artifactId>
  <version>${version.wildfly-swarm}</version>
  <executions>
    ...
    <configuration>
      ...
    <configuration/>
  </executions>
</plugin>

5.1.1. Goals

The WildFly Swarm 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 WildFly Swarm–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.2. Configuration

The plugin accepts the following options:

Name Property Description Default Used by

bundleDependencies

swarm.bundleDependencies

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

true

package

debug

none

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

run, start

environment

none

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

multistart, run, start

environmentFile

swarm.environmentFile

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

multistart, run, start

fractionDetectMode

swarm.fractionDetectMode

The mode of fraction detection. The available options are:

  • when_missing: Runs only when no WildFly Swarm dependencies are found.

  • force: Always run, and merge any detected fractions with the existing dependencies. Existing dependencies take precedence.

  • never: Disable fraction detection.

when_missing

package, run, start

fractions

none

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:name:version * name:version * name

If no group is provided, org.wildfly.swarm is assumed.

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

package, run, start

hollow

swarm.hollow

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

false

package

jvmArguments

swarm.jvmArguments

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

multistart, run, start

modules

none

Paths to a directory containing additional module definitions.

package, run, start

processes

none

Application configurations to start (see multistart).

multistart

properties

none

See Properties.

package, run, start

propertiesFile

swarm.propertiesFile

See Properties.

package, run, start

stderrFile

swarm.stderr

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

run, start

stdoutFile

swarm.stdout

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

run, start

useUberJar

swarm.useUberJar

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

false

run, start

Properties

Properties can be used to configure 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 wildfly-swarm:run command. In addition to that, the same properties are added to your myapp-swarm.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.

    • swarm.

    • maven.

  • The properties that override a property specified in the <properties> section or the <propertiesFile>.

5.2. Configuration of a WildFly Swarm Application

Every application built with WildFly Swarm has a many configurable options. In all cases, reasonable defaults are already applied, therefore 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. Configure your application using properties

In this document, configuration items are presented using dotted notation, and are suitable for use as Java property names, which your application consumes through explicit setting in the Maven plugin configuration, or through the command line when executing your application.

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.

Example 1. Using configuration items with the KEY parameter

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

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

Maven plugin properties

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.

Example 2. Setting a configuration item through the Maven Plugin

An example Maven plugin configuration for the swarm.bind.address item:

<build>
  <plugins>
    <plugin>
      <groupId>org.wildfly.swarm</groupId>
      <artifactId>wildfly-swarm-plugin</artifactId>
      <version>2017.11.0</version>
      <configuration>
        <properties>
          <swarm.bind.address>127.0.0.1</swarm.bind.address>
          <java.net.preferIPv4Stack>true</java.net.preferIPv4Stack>
        </properties>
      </configuration>
    </plugin>
  </plugins>
</build>
Note
It is not recommended to use the Maven plugin to explicitly set properties to control the configuration. Instead, using the YAML method is recommended.
Setting properties using the Command Line

Even hough setting properties using the Maven plugin is not recommended, it is useful for temporarily changing a configuration item for a single launch of your application. You can customize an environment-specific setting or experiment with configuration items before committing them to YAML.

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

$ java -Dswarm.bind.address=127.0.0.1 -jar myapp-swarm.jar

5.2.2. Configure your application using YAML

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 can be selectively enabled when launching the application.

General YAML format

The configuration names correspond to the YAML configuration structure.

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

swarm:
  undertow:
    servers:
      default:
        default-host: <myhost>
Default YAML Files

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 WildFly Swarm provides to your application.

Additionally, if you provide specific configuration files using the -S <name> command-line option, those files are loaded, in that order, before project-defaults.yml. A name provided in the -S <name> argument specifies the project-<name>.yml file on your classpath.

Example 3. Specifying configuration files on the command line

Consider the following application execution:

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

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

  1. project-testing.yml

  2. project-cloud.yml

  3. project-defaults.yml

Non-default YAML Files

If you want to reference a YAML file that exists outside of your application, use the -s <path> command-line option.

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 4. Specifying configuration files inside and outside of the application

Consider the following application execution:

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

In this example, the following YAML files are loaded in this order:

  1. /home/app/openshift.yml

  2. project-cloud.yml

  3. project-testing.yml

  4. project-defaults.yml

The same order of preference is applied even when the application is invoked as follows:

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

5.3. Network

For network configuration, create or adjust interfaces, socket-bindings, and outbound-socket-bindings. The networking configuration is stored under the networkswarm 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 5. Additional interface configuration

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

swarm:
  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:

  • swarm.bind.address

  • swarm.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 6. Socket-binding group

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

swarm:
  network:
    socket-binding-groups:
      standard-sockets:
        port-offset: 10
        default-interface: public
Example 7. Socket binding

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

swarm:
  network:
    socket-binding-groups:
      standard-sockets:
        http:
          port: 8081
Example 8. Outbound socket binding

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

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

5.4. The usage.txt file

Each WildFly Swarm 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 ${swarm.thing} format:

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

6. Fractions

6.1. Archaius

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>archaius</artifactId>
</dependency>

6.2. AsciidoctorJ

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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>org.wildfly.swarm</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.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>org.wildfly.swarm</groupId>
  <artifactId>bean-validation</artifactId>
</dependency>

6.5. Camel Core

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-core</artifactId>
</dependency>
Configuration
swarm.camel.contexts

(not yet documented)

swarm.camel.route-builders

(not yet documented)

6.5.1. Camel Component :: Activemq

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-activemq</artifactId>
</dependency>

6.5.2. Camel Component :: Ahc

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ahc</artifactId>
</dependency>
Camel Component :: Ahc-ws
Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ahc-ws</artifactId>
</dependency>

6.5.3. Camel Component :: Amqp

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-amqp</artifactId>
</dependency>

6.5.4. Camel Component :: Atom

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-atom</artifactId>
</dependency>

6.5.5. Camel Component :: Avro

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-avro</artifactId>
</dependency>

6.5.6. Camel Component :: Aws

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-aws</artifactId>
</dependency>

6.5.7. Camel Component :: Barcode

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-barcode</artifactId>
</dependency>

6.5.8. Camel Component :: Base64

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-base64</artifactId>
</dependency>

6.5.9. Camel Component :: Bean-validator

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-bean-validator</artifactId>
</dependency>

6.5.10. Camel Component :: Beanio

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-beanio</artifactId>
</dependency>

6.5.11. Camel Component :: Bindy

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-bindy</artifactId>
</dependency>

6.5.12. Camel Component :: Box

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-box</artifactId>
</dependency>

6.5.13. Camel Component :: Braintree

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-braintree</artifactId>
</dependency>

6.5.14. Camel Component :: Cassandraql

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-cassandraql</artifactId>
</dependency>

6.5.15. Camel Component :: Castor

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-castor</artifactId>
</dependency>

6.5.16. Camel Component :: Cdi

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-cdi</artifactId>
</dependency>

6.5.17. Camel Component :: Coap

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-coap</artifactId>
</dependency>

6.5.18. Camel Component :: Context

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-context</artifactId>
</dependency>

6.5.19. Camel Component :: Couchdb

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-couchdb</artifactId>
</dependency>

6.5.20. Camel Component :: Crypto

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-crypto</artifactId>
</dependency>

6.5.21. Camel Component :: Csv

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-csv</artifactId>
</dependency>

6.5.22. Camel Component :: Cxf

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-cxf</artifactId>
</dependency>

6.5.23. Camel Component :: Dns

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-dns</artifactId>
</dependency>

6.5.24. Camel Component :: Dozer

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-dozer</artifactId>
</dependency>

6.5.25. Camel Component :: Dropbox

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-dropbox</artifactId>
</dependency>

6.5.26. Camel Component :: Ejb

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ejb</artifactId>
</dependency>

6.5.27. Camel Component :: Elasticsearch

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-elasticsearch</artifactId>
</dependency>

6.5.28. Camel Component :: Elsql

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-elsql</artifactId>
</dependency>

6.5.29. Camel Component :: Exec

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-exec</artifactId>
</dependency>

6.5.30. Camel Component :: Facebook

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-facebook</artifactId>
</dependency>

6.5.31. Camel Component :: Flatpack

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-flatpack</artifactId>
</dependency>

6.5.32. Camel Component :: Freemarker

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-freemarker</artifactId>
</dependency>

6.5.33. Camel Component :: Ftp

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ftp</artifactId>
</dependency>

6.5.34. Camel Component :: Git

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-git</artifactId>
</dependency>

6.5.35. Camel Component :: Github

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-github</artifactId>
</dependency>

6.5.36. Camel Component :: Groovy

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-groovy</artifactId>
</dependency>

6.5.37. Camel Component :: Gson

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-gson</artifactId>
</dependency>

6.5.38. Camel Component :: Hl7

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-hl7</artifactId>
</dependency>

6.5.39. Camel Component :: Http4

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-http4</artifactId>
</dependency>

6.5.40. Camel Component :: Hystrix

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-hystrix</artifactId>
</dependency>

6.5.41. Camel Component :: Infinispan

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-infinispan</artifactId>
</dependency>

6.5.42. Camel Component :: Influxdb

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-influxdb</artifactId>
</dependency>

6.5.43. Camel Component :: Irc

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-irc</artifactId>
</dependency>

6.5.44. Camel Component :: Jackson

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jackson</artifactId>
</dependency>

6.5.45. Camel Component :: Jacksonxml

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jacksonxml</artifactId>
</dependency>

6.5.46. Camel Component :: Jasypt

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jasypt</artifactId>
</dependency>

6.5.47. Camel Component :: Jaxb

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jaxb</artifactId>
</dependency>

6.5.48. Camel Component :: Jbpm

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jbpm</artifactId>
</dependency>

6.5.49. Camel Component :: Jcache

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jcache</artifactId>
</dependency>

6.5.50. Camel Component :: Jdbc

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jdbc</artifactId>
</dependency>

6.5.51. Camel Component :: Jgroups

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jgroups</artifactId>
</dependency>

6.5.52. Camel Component :: Jms

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jms</artifactId>
</dependency>

6.5.53. Camel Component :: Jmx

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jmx</artifactId>
</dependency>

6.5.54. Camel Component :: Jpa

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jpa</artifactId>
</dependency>

6.5.55. Camel Component :: Jsch

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jsch</artifactId>
</dependency>

6.5.56. Camel Component :: Jsonpath

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-jsonpath</artifactId>
</dependency>

6.5.57. Camel Component :: Kafka

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-kafka</artifactId>
</dependency>

6.5.58. Camel Component :: Kubernetes

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-kubernetes</artifactId>
</dependency>

6.5.59. Camel Component :: Ldap

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ldap</artifactId>
</dependency>

6.5.60. Camel Component :: Linkedin

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-linkedin</artifactId>
</dependency>

6.5.61. Camel Component :: Lucene

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-lucene</artifactId>
</dependency>

6.5.62. Camel Component :: Mail

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mail</artifactId>
</dependency>

6.5.63. Camel Component :: Metrics

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-metrics</artifactId>
</dependency>

6.5.64. Camel Component :: Mina2

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mina2</artifactId>
</dependency>

6.5.65. Camel Component :: Mllp

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mllp</artifactId>
</dependency>

6.5.66. Camel Component :: Mongodb

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mongodb</artifactId>
</dependency>

6.5.67. Camel Component :: Mqtt

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mqtt</artifactId>
</dependency>

6.5.68. Camel Component :: Mvel

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mvel</artifactId>
</dependency>

6.5.69. Camel Component :: Mybatis

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-mybatis</artifactId>
</dependency>

6.5.70. Camel Component :: Nats

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-nats</artifactId>
</dependency>

6.5.71. Camel Component :: Netty4

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-netty4</artifactId>
</dependency>

6.5.72. Camel Component :: Ognl

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ognl</artifactId>
</dependency>

6.5.73. Camel Component :: Olingo2

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-olingo2</artifactId>
</dependency>

6.5.74. Camel Component :: Optaplanner

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-optaplanner</artifactId>
</dependency>

6.5.75. Camel Component :: Paho

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-paho</artifactId>
</dependency>

6.5.76. Camel Component :: Pdf

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-pdf</artifactId>
</dependency>

6.5.77. Camel Component :: Protobuf

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-protobuf</artifactId>
</dependency>

6.5.78. Camel Component :: Quartz2

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-quartz2</artifactId>
</dependency>

6.5.79. Camel Component :: Rabbitmq

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-rabbitmq</artifactId>
</dependency>

6.5.80. Camel Component :: Reactive-streams

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-reactive-streams</artifactId>
</dependency>

6.5.81. Camel Component :: Rest-swagger

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-rest-swagger</artifactId>
</dependency>

6.5.82. Camel Component :: Rss

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-rss</artifactId>
</dependency>

6.5.83. Camel Component :: Salesforce

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-salesforce</artifactId>
</dependency>

6.5.84. Camel Component :: Sap-netweaver

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-sap-netweaver</artifactId>
</dependency>

6.5.85. Camel Component :: Saxon

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-saxon</artifactId>
</dependency>

6.5.86. Camel Component :: Schematron

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-schematron</artifactId>
</dependency>

6.5.87. Camel Component :: Script

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-script</artifactId>
</dependency>

6.5.88. Camel Component :: Servicenow

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-servicenow</artifactId>
</dependency>

6.5.89. Camel Component :: Servlet

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-servlet</artifactId>
</dependency>

6.5.90. Camel Component :: Sjms

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-sjms</artifactId>
</dependency>

6.5.91. Camel Component :: Sjms2

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-sjms2</artifactId>
</dependency>

6.5.92. Camel Component :: Smpp

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-smpp</artifactId>
</dependency>

6.5.93. Camel Component :: Snakeyaml

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-snakeyaml</artifactId>
</dependency>

6.5.94. Camel Component :: Snmp

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-snmp</artifactId>
</dependency>

6.5.95. Camel Component :: Soap

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-soap</artifactId>
</dependency>

6.5.96. Camel Component :: Splunk

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-splunk</artifactId>
</dependency>

6.5.97. Camel Component :: Spring-batch

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-spring-batch</artifactId>
</dependency>

6.5.98. Camel Component :: Spring-integration

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-spring-integration</artifactId>
</dependency>

6.5.99. Camel Component :: Spring-ldap

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-spring-ldap</artifactId>
</dependency>

6.5.100. Camel Component :: Spring-redis

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-spring-redis</artifactId>
</dependency>

6.5.101. Camel Component :: Spring-security

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-spring-security</artifactId>
</dependency>

6.5.102. Camel Component :: Sql

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-sql</artifactId>
</dependency>

6.5.103. Camel Component :: Ssh

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-ssh</artifactId>
</dependency>

6.5.104. Camel Component :: Stax

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-stax</artifactId>
</dependency>

6.5.105. Camel Component :: Stream

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-stream</artifactId>
</dependency>

6.5.106. Camel Component :: Swagger

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-swagger</artifactId>
</dependency>

6.5.107. Camel Component :: Syslog

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-syslog</artifactId>
</dependency>

6.5.108. Camel Component :: Tagsoup

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-tagsoup</artifactId>
</dependency>

6.5.109. Camel Component :: Tarfile

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-tarfile</artifactId>
</dependency>

6.5.110. Camel Component :: Twitter

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-twitter</artifactId>
</dependency>

6.5.111. Camel Component :: Undertow

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-undertow</artifactId>
</dependency>

6.5.112. Camel Component :: Velocity

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-velocity</artifactId>
</dependency>

6.5.113. Camel Component :: Vertx

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-vertx</artifactId>
</dependency>

6.5.114. Camel Component :: Weather

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-weather</artifactId>
</dependency>

6.5.115. Camel Component :: Xmlbeans

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-xmlbeans</artifactId>
</dependency>

6.5.116. Camel Component :: Xmlsecurity

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-xmlsecurity</artifactId>
</dependency>

6.5.117. Camel Component :: Xstream

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-xstream</artifactId>
</dependency>

6.5.118. Camel Component :: Zipfile

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-zipfile</artifactId>
</dependency>

6.5.119. Camel Component :: Zipkin

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-zipkin</artifactId>
</dependency>

6.5.120. Camel Component :: Zookeeper

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>camel-zookeeper</artifactId>
</dependency>

6.6. Cassandra

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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>org.wildfly.swarm</groupId>
  <artifactId>cdi</artifactId>
</dependency>
Configuration
swarm.c-d-i.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.c-d-i.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.c-d-i.require-bean-descriptor

If true then implicit bean archives without bean descriptor file (beans.xml) are ignored by Weld

6.7.1. CDI Configuration

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>cdi-config</artifactId>
</dependency>

6.7.2. CDI JAX-RS API Enhancements

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>cdi-jaxrsapi</artifactId>
</dependency>

6.8. JBoss CLI

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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>org.wildfly.swarm</groupId>
  <artifactId>connector</artifactId>
</dependency>

6.10. Container

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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 WildFly Swarm 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

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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.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.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.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. Valid values are: FailingConnectionOnly (default), IdleConnections and EntirePool

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 should use 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 security domain which defines the 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

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.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.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.xa-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.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.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.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. Valid values are: FailingConnectionOnly (default), IdleConnections and EntirePool

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 should use 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-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 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

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

swarm.ds.connection.url

Default datasource connection URL

swarm.ds.name

Name of the default datasource

swarm.ds.password

Defatul datasource connection password

swarm.ds.username

Default datasource connection user name

swarm.jdbc.driver

Defatul datasource JDBC driver name

6.12. Drools Server

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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>org.wildfly.swarm</groupId>
  <artifactId>ee</artifactId>
</dependency>
Configuration
swarm.e-e.annotation-property-replacement

Flag indicating whether Java EE annotations will have property replacements applied

swarm.e-e.context-services.KEY.jndi-name

The JNDI Name to lookup the context service.

swarm.e-e.context-services.KEY.use-transaction-setup-provider

Flag which indicates if the transaction setup provider should be used

swarm.e-e.default-bindings-service.context-service

The JNDI name where the default EE Context Service can be found

swarm.e-e.default-bindings-service.datasource

The JNDI name where the default EE Datasource can be found

swarm.e-e.default-bindings-service.jms-connection-factory

The JNDI name where the default EE JMS Connection Factory can be found

swarm.e-e.default-bindings-service.managed-executor-service

The JNDI name where the default EE Managed Executor Service can be found

swarm.e-e.default-bindings-service.managed-scheduled-executor-service

The JNDI name where the default EE Managed Scheduled Executor Service can be found

swarm.e-e.default-bindings-service.managed-thread-factory

The JNDI name where the default EE Managed Thread Factory can be found

swarm.e-e.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.e-e.global-modules

A list of modules that should be made available to all deployments.

swarm.e-e.jboss-descriptor-property-replacement

Flag indicating whether JBoss specific deployment descriptors will have property replacements applied

swarm.e-e.managed-executor-services.KEY.context-service

The name of the context service to be used by the executor.

swarm.e-e.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.e-e.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.e-e.managed-executor-services.KEY.jndi-name

The JNDI Name to lookup the managed executor service.

swarm.e-e.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.e-e.managed-executor-services.KEY.long-running-tasks

Flag which hints the duration of tasks executed by the executor.

swarm.e-e.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.e-e.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.e-e.managed-executor-services.KEY.reject-policy

The policy to be applied to aborted tasks.

swarm.e-e.managed-executor-services.KEY.thread-factory

The name of the thread factory to be used by the executor.

swarm.e-e.managed-scheduled-executor-services.KEY.context-service

The name of the context service to be used by the scheduled executor.

swarm.e-e.managed-scheduled-executor-services.KEY.core-threads

The minimum number of threads to be used by the scheduled executor.

swarm.e-e.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.e-e.managed-scheduled-executor-services.KEY.jndi-name

The JNDI Name to lookup the managed scheduled executor service.

swarm.e-e.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.e-e.managed-scheduled-executor-services.KEY.long-running-tasks

Flag which hints the duration of tasks executed by the scheduled executor.

swarm.e-e.managed-scheduled-executor-services.KEY.reject-policy

The policy to be applied to aborted tasks.

swarm.e-e.managed-scheduled-executor-services.KEY.thread-factory

The name of the thread factory to be used by the scheduled executor.

swarm.e-e.managed-thread-factories.KEY.context-service

The name of the context service to be used by the managed thread factory

swarm.e-e.managed-thread-factories.KEY.jndi-name

The JNDI Name to lookup the managed thread factory.

swarm.e-e.managed-thread-factories.KEY.priority

The priority applied to threads created by the factory

swarm.e-e.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>org.wildfly.swarm</groupId>
  <artifactId>ejb</artifactId>
</dependency>
Configuration
swarm.ejb3.async-service.thread-pool-name

The name of the thread pool which handles asynchronous invocations

swarm.ejb3.caches.KEY.aliases

The aliases by which this cache may also be referenced

swarm.ejb3.caches.KEY.passivation-store

The passivation store used by this cache

swarm.ejb3.cluster-passivation-stores.KEY.bean-cache

The name of the cache used to store bean instances.

swarm.ejb3.cluster-passivation-stores.KEY.cache-container

The name of the cache container used for the bean and client-mappings caches

swarm.ejb3.cluster-passivation-stores.KEY.idle-timeout

The timeout in units specified by idle-timeout-unit, after which a bean will passivate

swarm.ejb3.cluster-passivation-stores.KEY.max-size

The maximum number of beans this cache should store before forcing old beans to passivate

swarm.ejb3.default-distinct-name

The default distinct name that is applied to every EJB deployed on this server

swarm.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

swarm.ejb3.default-entity-bean-optimistic-locking

If set to true entity beans will use optimistic locking by default

swarm.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

swarm.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

swarm.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

swarm.ejb3.default-security-domain

The default security domain that will be used for EJBs if the bean doesn’t explicitly specify one

swarm.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

swarm.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.

swarm.ejb3.default-singleton-bean-access-timeout

The default access timeout for singleton beans

swarm.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

swarm.ejb3.default-stateful-bean-access-timeout

The default access timeout for stateful beans

swarm.ejb3.enable-statistics

If set to true, enable the collection of invocation statistics.

swarm.ejb3.file-passivation-stores.KEY.idle-timeout

The timeout in units specified by idle-timeout-unit, after which a bean will passivate

swarm.ejb3.file-passivation-stores.KEY.max-size

The maximum number of beans this cache should store before forcing old beans to passivate

swarm.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

swarm.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)

swarm.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.

swarm.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)

swarm.ejb3.mdb-delivery-groups.KEY.active

Indicates if delivery for all MDBs belonging to this group is active

swarm.ejb3.passivation-stores.KEY.bean-cache

The name of the cache used to store bean instances.

swarm.ejb3.passivation-stores.KEY.cache-container

The name of the cache container used for the bean and client-mappings caches

swarm.ejb3.passivation-stores.KEY.max-size

The maximum number of beans this cache should store before forcing old beans to passivate

swarm.ejb3.remote-service.channel-creation-options.KEY.type

The type of the channel creation option

swarm.ejb3.remote-service.channel-creation-options.KEY.value

The value for the EJB remote channel creation option

swarm.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

swarm.ejb3.remote-service.connector-ref

The name of the connector on which the EJB3 remoting channel is registered

swarm.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

swarm.ejb3.remote-service.thread-pool-name

The name of the thread pool that handles remote invocations

swarm.ejb3.remoting-profiles.KEY.exclude-local-receiver

If set no local receiver is used in this profile

swarm.ejb3.remoting-profiles.KEY.local-receiver-pass-by-value

If set local receiver will pass ejb beans by value

swarm.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.channel-creation-options.KEY.type

The type of the channel creation option

swarm.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.channel-creation-options.KEY.value

The value for the EJB remote channel creation option

swarm.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.connect-timeout

Remoting ejb receiver connect timeout

swarm.ejb3.remoting-profiles.KEY.remoting-ejb-receivers.KEY.outbound-connection-ref

Name of outbound connection that will be used by the ejb receiver

swarm.ejb3.strict-max-bean-instance-pools.KEY.derive-size

Specifies if and what the max pool size should be derived from. A value of 'none', the default, 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.

swarm.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

swarm.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

swarm.ejb3.strict-max-bean-instance-pools.KEY.timeout-unit

The instance acquisition timeout unit

swarm.ejb3.thread-pools.KEY.active-count

The approximate number of threads that are actively executing tasks.

swarm.ejb3.thread-pools.KEY.completed-task-count

The approximate total number of tasks that have completed execution.

swarm.ejb3.thread-pools.KEY.current-thread-count

The current number of threads in the pool.

swarm.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.

swarm.ejb3.thread-pools.KEY.largest-thread-count

The largest number of threads that have ever simultaneously been in the pool.

swarm.ejb3.thread-pools.KEY.max-threads

The maximum thread pool size.

swarm.ejb3.thread-pools.KEY.name

The name of the thread pool.

swarm.ejb3.thread-pools.KEY.queue-size

The queue size.

swarm.ejb3.thread-pools.KEY.rejected-count

The number of tasks that have been rejected.

swarm.ejb3.thread-pools.KEY.task-count

The approximate total number of tasks that have ever been scheduled for execution.

swarm.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.

swarm.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.

swarm.ejb3.timer-service.database-data-stores.KEY.database

The type of database that is in use. SQL can be customised per database type.

swarm.ejb3.timer-service.database-data-stores.KEY.datasource-jndi-name

The datasource that is used to persist the timers

swarm.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.

swarm.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.

swarm.ejb3.timer-service.default-data-store

The default data store used for persistent timers

swarm.ejb3.timer-service.file-data-stores.KEY.path

The directory to store persistent timer information in

swarm.ejb3.timer-service.file-data-stores.KEY.relative-to

The relative path that is used to resolve the timer data store location

swarm.ejb3.timer-service.thread-pool-name

The name of the thread pool used to run timer service invocations

6.14.1. EJB Remote

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>ejb-remote</artifactId>
</dependency>

6.15. Fluentd

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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.16. Flyway

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>flyway</artifactId>
</dependency>
Configuration
swarm.flyway.jdbc-password

JDBC connection password

swarm.flyway.jdbc-url

JDBC connection URL

swarm.flyway.jdbc-user

JDBC connection user name

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>hibernate-search</artifactId>
</dependency>

6.18. Hibernate Validator

Provides support and integration for applications using Hibernate Validator.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>hibernate-validator</artifactId>
</dependency>

6.19. Hystrix

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>hystrix</artifactId>
</dependency>
Configuration
swarm.hystrix.collapser.default.maxRequestsInBatch

The maximum number of requests allowed in a batch before this triggers a batch execution

swarm.hystrix.collapser.default.requestCache.enabled

Indicates whether request caching is enabled for HystrixCollapser.execute() and HystrixCollapser.queue() invocations

swarm.hystrix.collapser.default.timerDelayInMilliseconds

The number of milliseconds after the creation of the batch that its execution is triggered

swarm.hystrix.command.default.circuitBreaker.enabled

Determines whether a circuit breaker will be used to track health and to short-circuit requests if it trips

swarm.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

swarm.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

swarm.hystrix.command.default.circuitBreaker.forceOpen

If true, forces the circuit breaker into an open (tripped) state in which it will reject all requests

swarm.hystrix.command.default.circuitBreaker.requestVolumeThreshold

The minimum number of requests in a rolling window that will trip the circuit

swarm.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

swarm.hystrix.command.default.execution.isolation.semaphore.maxConcurrentRequests

The maximum number of requests allowed to a HystrixCommand.run() method when you are using ExecutionIsolationStrategy.SEMAPHORE

swarm.hystrix.command.default.execution.isolation.strategy

Isolation strategy (THREAD or SEMAPHORE)

swarm.hystrix.command.default.execution.isolation.thread.interruptOnCancel

Indicates whether the HystrixCommand.run() execution should be interrupted when a cancellation occurs

swarm.hystrix.command.default.execution.isolation.thread.interruptOnTimeout

Indicates whether the HystrixCommand.run() execution should be interrupted when a timeout occurs

swarm.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

swarm.hystrix.command.default.execution.timeout.enabled

Indicates whether the HystrixCommand.run() execution should have a timeout

swarm.hystrix.command.default.fallback.enabled

Determines whether a call to HystrixCommand.getFallback() will be attempted when failure or rejection occurs

swarm.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

swarm.hystrix.command.default.metrics.rollingPercentile.bucketSize

The maximum number of execution times that are kept per bucket

swarm.hystrix.command.default.metrics.rollingPercentile.enabled

Indicates whether execution latencies should be tracked and calculated as percentiles

swarm.hystrix.command.default.metrics.rollingPercentile.numBuckets

The number of buckets the rollingPercentile window will be divided into

swarm.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

swarm.hystrix.command.default.metrics.rollingStats.numBuckets

The number of buckets the rolling statistical window is divided into

swarm.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

swarm.hystrix.command.default.requestCache.enabled

Indicates whether HystrixCommand.getCacheKey() should be used with HystrixRequestCache to provide de-duplication functionality via request-scoped caching

swarm.hystrix.command.default.requestLog.enabled

Indicates whether HystrixCommand execution and events should be logged to HystrixRequestLog

swarm.hystrix.stream.path

Context path for the stream

swarm.hystrix.threadpool.default.allowMaximumSizeToDivergeFromCoreSize

Allows the configuration for maximumSize to take effect

swarm.hystrix.threadpool.default.coreSize

The core thread-pool size

swarm.hystrix.threadpool.default.keepAliveTimeMinutes

The keep-alive time, in minutes

swarm.hystrix.threadpool.default.maxQueueSize

The maximum queue size of the BlockingQueue implementation

swarm.hystrix.threadpool.default.maximumSize

The maximum thread-pool size

swarm.hystrix.threadpool.default.metrics.rollingPercentile.numBuckets

The number of buckets the rolling statistical window is divided into

swarm.hystrix.threadpool.default.metrics.rollingStats.timeInMilliseconds

The duration of the statistical rolling window, in milliseconds

swarm.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.20. Infinispan

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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.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.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.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-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.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. f 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.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.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. f 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.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.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. f 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.invalidations

The number of cache invalidations. May return null if the cache is not started.

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.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.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-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.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. f 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-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.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.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.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. f 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.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.string-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.string-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.string-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.string-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.string-jdbc-store.data-source

References the data source used to connect to this store.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-jdbc-store.dialect

The dialect of this datastore.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-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.string-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. f 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.string-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.string-jdbc-store.properties

A list of cache store properties.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-jdbc-store.properties.KEY.value

The value of the cache store property.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-jdbc-store.purge

If true, purges this cache store when it starts up.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-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.string-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.string-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.string-jdbc-store.string-table.data-column

A database column to hold cache entry data.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-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.string-jdbc-store.string-table.id-column

A database column to hold cache entry ids.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-jdbc-store.string-table.prefix

The prefix for the database table name.

swarm.infinispan.cache-containers.KEY.distributed-caches.KEY.string-jdbc-store.string-table.timestamp-column

A database column to hold cache entry timestamps.

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.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.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.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-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.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. f 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.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.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. f 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.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.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. f 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.invalidations

The number of cache invalidations. May return null if the cache is not started.

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.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.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-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.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. f 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-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.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.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.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. f 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.string-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.string-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.string-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.string-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.string-jdbc-store.data-source

References the data source used to connect to this store.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-jdbc-store.dialect

The dialect of this datastore.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-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.string-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. f 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.string-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.string-jdbc-store.properties

A list of cache store properties.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-jdbc-store.properties.KEY.value

The value of the cache store property.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-jdbc-store.purge

If true, purges this cache store when it starts up.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-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.string-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.string-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.string-jdbc-store.string-table.data-column

A database column to hold cache entry data.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-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.string-jdbc-store.string-table.id-column

A database column to hold cache entry ids.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-jdbc-store.string-table.prefix

The prefix for the database table name.

swarm.infinispan.cache-containers.KEY.invalidation-caches.KEY.string-jdbc-store.string-table.timestamp-column

A database column to hold cache entry timestamps.

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.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.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-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.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. f 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.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.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. f 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.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.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. f 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.invalidations

The number of cache invalidations. May return null if the cache is not started.

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.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.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-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.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. f 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-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.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.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. f 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.string-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.string-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.string-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.string-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.string-jdbc-store.data-source

References the data source used to connect to this store.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-jdbc-store.dialect

The dialect of this datastore.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-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.string-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. f 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.string-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.string-jdbc-store.properties

A list of cache store properties.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-jdbc-store.properties.KEY.value

The value of the cache store property.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-jdbc-store.purge

If true, purges this cache store when it starts up.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-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.string-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.string-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.string-jdbc-store.string-table.data-column

A database column to hold cache entry data.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-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.string-jdbc-store.string-table.id-column

A database column to hold cache entry ids.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-jdbc-store.string-table.prefix

The prefix for the database table name.

swarm.infinispan.cache-containers.KEY.local-caches.KEY.string-jdbc-store.string-table.timestamp-column

A database column to hold cache entry timestamps.

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.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.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.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-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.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. f 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.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.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. f 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.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.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. f 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.invalidations

The number of cache invalidations. May return null if the cache is not started.

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.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.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-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.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. f 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-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.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.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.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. f 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.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.string-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.string-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.string-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.string-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.string-jdbc-store.data-source

References the data source used to connect to this store.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-jdbc-store.dialect

The dialect of this datastore.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-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.string-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. f 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.string-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.string-jdbc-store.properties

A list of cache store properties.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-jdbc-store.properties.KEY.value

The value of the cache store property.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-jdbc-store.purge

If true, purges this cache store when it starts up.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-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.string-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.string-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.string-jdbc-store.string-table.data-column

A database column to hold cache entry data.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-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.string-jdbc-store.string-table.id-column

A database column to hold cache entry ids.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-jdbc-store.string-table.prefix

The prefix for the database table name.

swarm.infinispan.cache-containers.KEY.replicated-caches.KEY.string-jdbc-store.string-table.timestamp-column

A database column to hold cache entry timestamps.

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.21. IO

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>io</artifactId>
</dependency>
Configuration
swarm.i-o.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.i-o.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.i-o.buffer-pools.KEY.direct-buffers

Does the buffer pool use direct buffers, some platforms don’t support direct buffers

swarm.i-o.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.i-o.workers.KEY.stack-size

The stack size (in bytes) to attempt to use for worker threads.

swarm.i-o.workers.KEY.task-keepalive

Specify the number of milliseconds to keep non-core task threads alive.

swarm.i-o.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

6.22. Jaeger

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jaeger</artifactId>
</dependency>
Configuration
swarm.jaeger.agent-host

The hostname for communicating with agent via UDP

swarm.jaeger.agent-port

The port for communicating with agent via UDP

swarm.jaeger.reporter-flush-interval

The reporter’s flush interval (ms)

swarm.jaeger.reporter-log-spans

Whether the reporter should also log the spans

swarm.jaeger.reporter-max-queue-size

The reporter’s maximum queue size

swarm.jaeger.sampler-manager-host

The host name and port when using the remote controlled sampler

swarm.jaeger.sampler-parameter

The sampler parameter (number). Ex.: 1

swarm.jaeger.sampler-type

The sampler type. Ex.: const

swarm.jaeger.service-name

The service name. Required (via this parameter, system property or env var). Ex.: order-manager

6.23. JavaFX

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>javafx</artifactId>
</dependency>

6.24. JAX-RS

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jaxrs</artifactId>
</dependency>
Configuration
swarm.deployment.KEY.jaxrs.application-path

Set the JAX-RS application path, if the JAX-RS application class is autogenerated by Swarm

6.24.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>org.wildfly.swarm</groupId>
  <artifactId>jaxrs-cdi</artifactId>
</dependency>

6.24.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>org.wildfly.swarm</groupId>
  <artifactId>jaxrs-jaxb</artifactId>
</dependency>

6.24.3. JAX-RS + JSON-P

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jaxrs-jsonp</artifactId>
</dependency>

6.24.4. JAX-RS + Multipart

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jaxrs-multipart</artifactId>
</dependency>

6.24.5. JAX-RS + Validator

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jaxrs-validator</artifactId>
</dependency>

6.25. JCA

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jca</artifactId>
</dependency>
Configuration
swarm.j-c-a.archive-validation.enabled

Specify whether archive validation is enabled

swarm.j-c-a.archive-validation.fail-on-error

Should an archive validation error report fail the deployment

swarm.j-c-a.archive-validation.fail-on-warn

Should an archive validation warning report fail the deployment

swarm.j-c-a.bean-validation.enabled

Specify whether bean validation is enabled

swarm.j-c-a.bootstrap-contexts.KEY.name

The name of the BootstrapContext

swarm.j-c-a.bootstrap-contexts.KEY.workmanager

The WorkManager instance for the BootstrapContext

swarm.j-c-a.cached-connection-manager.debug

Enable/disable debug information logging

swarm.j-c-a.cached-connection-manager.error

Enable/disable error information logging

swarm.j-c-a.cached-connection-manager.ignore-unknown-connections

Do not cache unknown connections

swarm.j-c-a.cached-connection-manager.install

Enable/disable the cached connection manager valve and interceptor

swarm.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.allow-core-timeout

Whether core threads may time out.

swarm.j-c-a.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.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.current-thread-count

The current number of threads in the pool.

swarm.j-c-a.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.j-c-a.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.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.largest-thread-count

The largest number of threads that have ever simultaneously been in the pool.

swarm.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.max-threads

The maximum thread pool size.

swarm.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.name

The name of the thread pool.

swarm.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.queue-length

The queue length.

swarm.j-c-a.distributed-workmanagers.KEY.long-running-threads.KEY.queue-size

The queue size.

swarm.j-c-a.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.j-c-a.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.j-c-a.distributed-workmanagers.KEY.name

The name of the DistributedWorkManager

swarm.j-c-a.distributed-workmanagers.KEY.policy

The policy decides when to redistribute a Work instance

swarm.j-c-a.distributed-workmanagers.KEY.policy-options

List of policy’s options key/value pairs

swarm.j-c-a.distributed-workmanagers.KEY.selector

The selector decides to which nodes in the network to redistribute the Work instance to

swarm.j-c-a.distributed-workmanagers.KEY.selector-options

List of selector’s options key/value pairs

swarm.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.allow-core-timeout

Whether core threads may time out.

swarm.j-c-a.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.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.current-thread-count

The current number of threads in the pool.

swarm.j-c-a.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.j-c-a.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.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.largest-thread-count

The largest number of threads that have ever simultaneously been in the pool.

swarm.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.max-threads

The maximum thread pool size.

swarm.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.name

The name of the thread pool.

swarm.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.queue-length

The queue length.

swarm.j-c-a.distributed-workmanagers.KEY.short-running-threads.KEY.queue-size

The queue size.

swarm.j-c-a.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.j-c-a.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.j-c-a.tracer.enabled

Specify whether tracer is enabled

swarm.j-c-a.workmanagers.KEY.long-running-threads.KEY.allow-core-timeout

Whether core threads may time out.

swarm.j-c-a.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.j-c-a.workmanagers.KEY.long-running-threads.KEY.current-thread-count

The current number of threads in the pool.

swarm.j-c-a.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.j-c-a.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.j-c-a.workmanagers.KEY.long-running-threads.KEY.largest-thread-count

The largest number of threads that have ever simultaneously been in the pool.

swarm.j-c-a.workmanagers.KEY.long-running-threads.KEY.max-threads

The maximum thread pool size.

swarm.j-c-a.workmanagers.KEY.long-running-threads.KEY.name

The name of the thread pool.

swarm.j-c-a.workmanagers.KEY.long-running-threads.KEY.queue-length

The queue length.

swarm.j-c-a.workmanagers.KEY.long-running-threads.KEY.queue-size

The queue size.

swarm.j-c-a.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.j-c-a.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.j-c-a.workmanagers.KEY.name

The name of the WorkManager

swarm.j-c-a.workmanagers.KEY.short-running-threads.KEY.allow-core-timeout

Whether core threads may time out.

swarm.j-c-a.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.j-c-a.workmanagers.KEY.short-running-threads.KEY.current-thread-count

The current number of threads in the pool.

swarm.j-c-a.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.j-c-a.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.j-c-a.workmanagers.KEY.short-running-threads.KEY.largest-thread-count

The largest number of threads that have ever simultaneously been in the pool.

swarm.j-c-a.workmanagers.KEY.short-running-threads.KEY.max-threads

The maximum thread pool size.

swarm.j-c-a.workmanagers.KEY.short-running-threads.KEY.name

The name of the thread pool.

swarm.j-c-a.workmanagers.KEY.short-running-threads.KEY.queue-length

The queue length.

swarm.j-c-a.workmanagers.KEY.short-running-threads.KEY.queue-size

The queue size.

swarm.j-c-a.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.j-c-a.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.26. JBoss Diagnostic Reporting

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jdr</artifactId>
</dependency>

6.27. JGroups

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jgroups</artifactId>
</dependency>
Configuration
swarm.default.multicast.address

Default multicast address for JGroups

swarm.j-groups.channels.KEY.address

The IP address of the channel.

swarm.j-groups.channels.KEY.address-as-uuid

The address of the channel as a UUID.

swarm.j-groups.channels.KEY.cluster

The cluster name of the JGroups channel. If undefined, the name of the channel will be used.

swarm.j-groups.channels.KEY.discard-own-messages

If true, do not receive messages sent by this node (ourself).

swarm.j-groups.channels.KEY.forks.KEY.protocols.KEY.module

The module with which to resolve the protocol type.

swarm.j-groups.channels.KEY.forks.KEY.protocols.KEY.properties

The properties of this protocol.

swarm.j-groups.channels.KEY.forks.KEY.protocols.KEY.properties.KEY.value

The value of a protocol property.

swarm.j-groups.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.j-groups.channels.KEY.module

The module from which to load channel services

swarm.j-groups.channels.KEY.num-tasks-in-timer

The current number of timer tasks.

swarm.j-groups.channels.KEY.num-timer-threads

The number of timer threads.

swarm.j-groups.channels.KEY.received-bytes

The number of bytes received by this channel.

swarm.j-groups.channels.KEY.received-messages

The number of messages received by this channel.

swarm.j-groups.channels.KEY.sent-bytes

The number of bytes sent by this channel.

swarm.j-groups.channels.KEY.sent-messages

The number of messages sent by this channel.

swarm.j-groups.channels.KEY.stack

The protocol stack of the JGroups channel

swarm.j-groups.channels.KEY.state

The state of the channel (OPEN, CONNECTING, CONNECTED, CLOSED).

swarm.j-groups.channels.KEY.stats-enabled

If enabled, collect channel statistics.

swarm.j-groups.channels.KEY.version

The JGroups software version.

swarm.j-groups.channels.KEY.view

The channel’s view of group membership.

swarm.j-groups.default-channel

The default JGroups channel.

swarm.j-groups.stacks.KEY.R-e-l-a-y2.properties

The properties of this protocol.

swarm.j-groups.stacks.KEY.R-e-l-a-y2.properties.KEY.value

The value of a protocol property.

swarm.j-groups.stacks.KEY.R-e-l-a-y2.remote-sites.KEY.channel

The name of the bridge channel used to communicate with this remote site.

swarm.j-groups.stacks.KEY.R-e-l-a-y2.site

The name of the local site.

swarm.j-groups.stacks.KEY.protocols.KEY.module

The module with which to resolve the protocol type.

swarm.j-groups.stacks.KEY.protocols.KEY.properties

The properties of this protocol.

swarm.j-groups.stacks.KEY.protocols.KEY.properties.KEY.value

The value of a protocol property.

swarm.j-groups.stacks.KEY.protocols.KEY.socket-binding

The socket binding specification for this protocol layer, used to specify IP interfaces and ports for communication.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.default-thread-pool.max-threads

The maximum thread pool size.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.default-thread-pool.queue-length

The queue length.

swarm.j-groups.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.j-groups.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.j-groups.stacks.KEY.transports.KEY.internal-thread-pool.max-threads

The maximum thread pool size.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.internal-thread-pool.queue-length

The queue length.

swarm.j-groups.stacks.KEY.transports.KEY.machine

The machine (i.e. host) identifier for this node. Used by Infinispan topology-aware consistent hash.

swarm.j-groups.stacks.KEY.transports.KEY.module

The module with which to resolve the protocol type.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.oob-thread-pool.max-threads

The maximum thread pool size.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.oob-thread-pool.queue-length

The queue length.

swarm.j-groups.stacks.KEY.transports.KEY.properties

The properties of this protocol.

swarm.j-groups.stacks.KEY.transports.KEY.properties.KEY.value

The value of a protocol property.

swarm.j-groups.stacks.KEY.transports.KEY.rack

The rack (i.e. server rack) identifier for this node. Used by Infinispan topology-aware consistent hash.

swarm.j-groups.stacks.KEY.transports.KEY.site

The site (i.e. data centre) identifier for this node. Used by Infinispan topology-aware consistent hash.

swarm.j-groups.stacks.KEY.transports.KEY.socket-binding

The socket binding specification for this protocol layer, used to specify IP interfaces and ports for communication.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.timer-thread-pool.max-threads

The maximum thread pool size.

swarm.j-groups.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.j-groups.stacks.KEY.transports.KEY.timer-thread-pool.queue-length

The queue length.

6.28. JMX

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jmx</artifactId>
</dependency>
Configuration
swarm.j-m-x.audit-log-configuration.enabled

Whether audit logging is enabled.

swarm.j-m-x.audit-log-configuration.log-boot

Whether operations should be logged on server boot.

swarm.j-m-x.audit-log-configuration.log-read-only

Whether operations that do not modify the configuration or any runtime services should be logged.

swarm.j-m-x.expression-expose-model.domain-name

The domain name to use for the 'expression' model controller JMX facade in the MBeanServer.

swarm.j-m-x.jmx-remoting-connector.use-management-endpoint

If true the connector will use the management endpoint, otherwise it will use the remoting subsystem one

swarm.j-m-x.non-core-mbean-sensitivity

Whether or not core MBeans, i.e. mbeans not coming from the model controller, should be considered sensitive.

swarm.j-m-x.resolved-expose-model.domain-name

The domain name to use for the 'resolved' model controller JMX facade in the MBeanServer.

swarm.j-m-x.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.j-m-x.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.29. Jolokia

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jolokia</artifactId>
</dependency>
Configuration
swarm.jolokia.context

Context path for the Jolokia endpoints

swarm.jolokia.jolokia-war-preparer

(not yet documented)

6.30. JPA

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jpa</artifactId>
</dependency>
Configuration
swarm.j-p-a.default-datasource

The name of the default global datasource.

swarm.j-p-a.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).

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jpa-eclipselink</artifactId>
</dependency>

6.30.2. JPA Spatial Extensions

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jpa-spatial</artifactId>
</dependency>

6.31. JSF

Provides support for JavaServer Faces according to JSR-344.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jsf</artifactId>
</dependency>
Configuration
swarm.j-s-f.default-jsf-impl-slot

Default JSF implementation slot

6.32. JSON-P

Provides support for JSON Processing according to JSR-353.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>jsonp</artifactId>
</dependency>

6.33. Keycloak

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>keycloak</artifactId>
</dependency>
Configuration
swarm.keycloak.json.path

Path to keycloak.json 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.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-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.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.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-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.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.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

6.33.1. Keycloak Server

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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'.

6.34. 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>org.wildfly.swarm</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.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.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.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.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 it’s 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.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.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.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.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 it’s 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.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.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.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.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.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.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.35. Logstash

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>logstash</artifactId>
</dependency>
Configuration
swarm.logstash.enabled

Flag to enable Logstash logging

swarm.logstash.formatter-properties

Logstash formatter properties

swarm.logstash.hostname

Host name of the Logstash server

swarm.logstash.level

Log level

swarm.logstash.port

Port of the Logstash server

6.36. Mail

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>mail</artifactId>
</dependency>
Configuration
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.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.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.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

swarm.mail.smtp.host

Host name of the default SMTP server

swarm.mail.smtp.port

Port of the default SMTP server

6.37. Management

Provides the WildFly management API.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>management</artifactId>
</dependency>
Configuration
swarm.management.audit-access.audit-log-logger.enabled

Whether audit logging is enabled.

swarm.management.audit-access.audit-log-logger.log-boot

Whether operations should be logged on server boot.

swarm.management.audit-access.audit-log-logger.log-read-only

Whether operations that do not modify the configuration or any runtime services should be logged.

swarm.management.audit-access.file-handlers.KEY.disabled-due-to-failure

Whether this handler has been disabled due to logging failures.

swarm.management.audit-access.file-handlers.KEY.failure-count

The number of logging failures since the handler was initialized.

swarm.management.audit-access.file-handlers.KEY.formatter

The formatter used to format the log messages.

swarm.management.audit-access.file-handlers.KEY.max-failure-count

The maximum number of logging failures before disabling this handler.

swarm.management.audit-access.file-handlers.KEY.path

The path of the audit log file.

swarm.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.

swarm.management.audit-access.in-memory-handlers.KEY.max-history

The maximum number of operation stored in history for this handler.

swarm.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.

swarm.management.audit-access.json-formatters.KEY.date-format

The date format to use as understood by {@link java.text.SimpleDateFormat}. Will be ignored if include-date="false".

swarm.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".

swarm.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".

swarm.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".

swarm.management.audit-access.json-formatters.KEY.include-date

Whether or not to include the date in the formatted log record.

swarm.management.audit-access.periodic-rotating-file-handlers.KEY.disabled-due-to-failure

Whether this handler has been disabled due to logging failures.

swarm.management.audit-access.periodic-rotating-file-handlers.KEY.failure-count

The number of logging failures since the handler was initialized.

swarm.management.audit-access.periodic-rotating-file-handlers.KEY.formatter

The formatter used to format the log messages.

swarm.management.audit-access.periodic-rotating-file-handlers.KEY.max-failure-count

The maximum number of logging failures before disabling this handler.

swarm.management.audit-access.periodic-rotating-file-handlers.KEY.path

The path of the audit log file.

swarm.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.

swarm.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.

swarm.management.audit-access.size-rotating-file-handlers.KEY.disabled-due-to-failure

Whether this handler has been disabled due to logging failures.

swarm.management.audit-access.size-rotating-file-handlers.KEY.failure-count

The number of logging failures since the handler was initialized.

swarm.management.audit-access.size-rotating-file-handlers.KEY.formatter

The formatter used to format the log messages.

swarm.management.audit-access.size-rotating-file-handlers.KEY.max-backup-index

The maximum number of backups to keep.

swarm.management.audit-access.size-rotating-file-handlers.KEY.max-failure-count

The maximum number of logging failures before disabling this handler.

swarm.management.audit-access.size-rotating-file-handlers.KEY.path

The path of the audit log file.

swarm.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.

swarm.management.audit-access.size-rotating-file-handlers.KEY.rotate-size

The size at which to rotate the log file.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.disabled-due-to-failure

Whether this handler has been disabled due to logging failures.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.failure-count

The number of logging failures since the handler was initialized.

swarm.management.audit-access.syslog-handlers.KEY.formatter

The formatter used to format the log messages.

swarm.management.audit-access.syslog-handlers.KEY.max-failure-count

The maximum number of logging failures before disabling this handler.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.syslog-format

Whether to set the syslog format to the one specified in RFC-5424 or RFC-3164.

swarm.management.audit-access.syslog-handlers.KEY.tcp-protocol.host

The host of the syslog server for the tcp requests.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.tcp-protocol.port

The port of the syslog server for the tcp requests.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.key-password

The password for the keystore key.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.keystore-password

The password for the keystore.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.client-certificate-store-authentication.keystore-path

=The path of the keystore.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.host

The host of the syslog server for the tls over tcp requests.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.port

The port of the syslog server for the tls over tcp requests.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.truststore-authentication.keystore-password

The password for the truststore.

swarm.management.audit-access.syslog-handlers.KEY.tls-protocol.truststore-authentication.keystore-path

=The path of the truststore.

swarm.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.

swarm.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.

swarm.management.audit-access.syslog-handlers.KEY.udp-protocol.host

The host of the syslog server for the udp requests.

swarm.management.audit-access.syslog-handlers.KEY.udp-protocol.port

The port of the syslog server for the udp requests.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.management.authorization-access.application-classification-constraint.types.KEY.classifications.KEY.default-application

Whether targets having this application type constraint are considered application resources.

swarm.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.

swarm.management.authorization-access.provider

The provider to use for management access control decisions.

swarm.management.authorization-access.role-mappings.KEY.excludes.KEY.name

The name of the user or group being mapped.

swarm.management.authorization-access.role-mappings.KEY.excludes.KEY.realm

An optional attribute to map based on the realm used for authentication.

swarm.management.authorization-access.role-mappings.KEY.excludes.KEY.type

The type of the Principal being mapped, either 'group' or 'user'.

swarm.management.authorization-access.role-mappings.KEY.include-all

Configure if all authenticated users should be automatically assigned this role.

swarm.management.authorization-access.role-mappings.KEY.includes.KEY.name

The name of the user or group being mapped.

swarm.management.authorization-access.role-mappings.KEY.includes.KEY.realm

An optional attribute to map based on the realm used for authentication.

swarm.management.authorization-access.role-mappings.KEY.includes.KEY.type

The type of the Principal being mapped, either 'group' or 'user'.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.management.authorization-access.sensitivity-classification-constraint.types.KEY.classifications.KEY.default-application

Whether targets having this application type constraint are considered application resources.

swarm.management.authorization-access.standard-role-names

The official names of the standard roles supported by the current management access control provider.

swarm.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.

swarm.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.

swarm.management.authorization-access.vault-expression-constraint.default-requires-read

Whether reading attributes containing vault expressions should be considered sensitive.

swarm.management.authorization-access.vault-expression-constraint.default-requires-write

Whether writing attributes containing vault expressions should be considered sensitive.

swarm.management.bind.interface

Interface to bind for the management ports

swarm.management.configuration-changes-service.max-history

The maximum number of configuration changes stored in history.

swarm.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.

swarm.management.http-interface-management-interface.console-enabled

Flag that indicates admin console is enabled

swarm.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

swarm.management.http-interface-management-interface.sasl-protocol

The name of the protocol to be passed to the SASL mechanisms used for authentication.

swarm.management.http-interface-management-interface.secure-socket-binding

The name of the socket binding configuration to use for the HTTPS management interface’s socket.

swarm.management.http-interface-management-interface.security-realm

The security realm to use for the HTTP management interface.

swarm.management.http-interface-management-interface.server-name

The name of the server used in the initial Remoting exchange and within the SASL mechanisms.

swarm.management.http-interface-management-interface.socket-binding

The name of the socket binding configuration to use for the HTTP management interface’s socket.

swarm.management.http.disable

Flag to disable HTTP access to management interface

swarm.management.http.port

Port for HTTP access to management interface

swarm.management.https.port

Port for HTTPS access to management interface

swarm.management.ldap-connections.KEY.handles-referrals-for

List of URLs that this connection handles referrals for.

swarm.management.ldap-connections.KEY.initial-context-factory

The initial context factory to establish the LdapContext.

swarm.management.ldap-connections.KEY.properties.KEY.value

The optional value of the property.

swarm.management.ldap-connections.KEY.referrals

The referral handling mode for this connection.

swarm.management.ldap-connections.KEY.search-credential

The credential to use when connecting to perform a search.

swarm.management.ldap-connections.KEY.search-dn

The distinguished name to use when connecting to the LDAP server to perform searches.

swarm.management.ldap-connections.KEY.security-realm

The security realm to reference to obtain a configured SSLContext to use when establishing the connection.

swarm.management.ldap-connections.KEY.url

The URL to use to connect to the LDAP server.

swarm.management.management-operations-service.active-operations.KEY.access-mechanism

The mechanism used to submit a request to the server.

swarm.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.

swarm.management.management-operations-service.active-operations.KEY.caller-thread

The name of the thread that is executing the operation.

swarm.management.management-operations-service.active-operations.KEY.cancelled

Whether the operation has been cancelled.

swarm.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.

swarm.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 is this operation is not associated with such a domain operation.

swarm.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.

swarm.management.management-operations-service.active-operations.KEY.execution-status

The current activity of the operation.

swarm.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.

swarm.management.management-operations-service.active-operations.KEY.running-time

Amount of time the operation has been executing.

swarm.management.native-interface-management-interface.sasl-protocol

The name of the protocol to be passed to the SASL mechanisms used for authentication.

swarm.management.native-interface-management-interface.security-realm

The security realm to use for the native management interface.

swarm.management.native-interface-management-interface.server-name

The name of the server used in the initial Remoting exchange and within the SASL mechanisms.

swarm.management.native-interface-management-interface.socket-binding

The name of the socket binding configuration to use for the native management interface’s socket.

swarm.management.security-realms.KEY.jaas-authentication.assign-groups

Map the roles loaded by JAAS to groups.

swarm.management.security-realms.KEY.jaas-authentication.name

The name of the JAAS configuration to use.

swarm.management.security-realms.KEY.kerberos-authentication.remove-realm

After authentication should the realm name be stripped from the users name.

swarm.management.security-realms.KEY.kerberos-server-identity.keytabs.KEY.debug

Should additional debug logging be enabled during TGT acquisition?

swarm.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.

swarm.management.security-realms.KEY.kerberos-server-identity.keytabs.KEY.path

The path to the keytab.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authentication.allow-empty-passwords

Should empty passwords be accepted from the user being authenticated.

swarm.management.security-realms.KEY.ldap-authentication.base-dn

The base distinguished name to commence the search for the user.

swarm.management.security-realms.KEY.ldap-authentication.by-access-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authentication.by-access-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authentication.by-search-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authentication.by-search-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authentication.connection

The name of the connection to use to connect to LDAP.

swarm.management.security-realms.KEY.ldap-authentication.recursive

Whether the search should be recursive.

swarm.management.security-realms.KEY.ldap-authentication.user-dn

The name of the attribute which is the user’s distinguished name.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.base-dn

The starting point of the search for the user.

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-access-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-access-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-search-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.by-search-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.filter

The filter to use for the LDAP search.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.advanced-filter-username-to-dn.recursive

Should levels below the starting point be recursively searched?

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.connection

The name of the connection to use to connect to LDAP.

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.base-dn

The starting point of the search for the group.

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-access-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-access-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-search-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.by-search-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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?

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.principal-attribute

The attribute on the group entry that references the principal.

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.recursive

Should levels below the starting point be recursively searched?

swarm.management.security-realms.KEY.ldap-authorization.group-to-principal-group-search.search-by

Should searches be performed using simple names or distinguished names?

swarm.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-access-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-access-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-search-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.principal-to-group-group-search.by-search-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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?

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.attribute

The attribute on the user entry that is their username.

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.base-dn

The starting point of the search for the user.

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-access-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-access-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-search-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.by-search-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.username-filter-username-to-dn.recursive

Should levels below the starting point be recursively searched?

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-access-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-access-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-search-time-cache.cache-failures

Should failures be cached?

swarm.management.security-realms.KEY.ldap-authorization.username-is-dn-username-to-dn.by-search-time-cache.cache-size

The current size of the cache.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.management.security-realms.KEY.local-authentication.default-user

The name of the default user to assume if no user specified by the remote client.

swarm.management.security-realms.KEY.local-authentication.skip-group-loading

Disable the loading of the users group membership information after local authentication has been used.

swarm.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.

swarm.management.security-realms.KEY.plug-in-authentication.mechanism

Allow the mechanism this plug-in is compatible with to be overridden from DIGEST.

swarm.management.security-realms.KEY.plug-in-authentication.name

The short name of the plug-in (as registered) to use.

swarm.management.security-realms.KEY.plug-in-authentication.properties.KEY.value

The optional value of the property.

swarm.management.security-realms.KEY.plug-in-authorization.name

The short name of the plug-in (as registered) to use.

swarm.management.security-realms.KEY.plug-in-authorization.properties.KEY.value

The optional value of the property.

swarm.management.security-realms.KEY.properties-authentication.path

The path of the properties file containing the users.

swarm.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'.

swarm.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.

swarm.management.security-realms.KEY.properties-authorization.path

The path of the properties file containing the users roles.

swarm.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.

swarm.management.security-realms.KEY.secret-server-identity.value

The secret / password - Base64 Encoded.

swarm.management.security-realms.KEY.ssl-server-identity.alias

The alias of the entry to use from the keystore.

swarm.management.security-realms.KEY.ssl-server-identity.enabled-cipher-suites

The cipher suites that can be enabled on the underlying SSLEngine.

swarm.management.security-realms.KEY.ssl-server-identity.enabled-protocols

The protocols that can be enabled on the underlying SSLEngine.

swarm.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.

swarm.management.security-realms.KEY.ssl-server-identity.key-password

The password to obtain the key from the keystore.

swarm.management.security-realms.KEY.ssl-server-identity.keystore-password

The password to open the keystore.

swarm.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.

swarm.management.security-realms.KEY.ssl-server-identity.keystore-provider

The provider for loading the keystore, defaults to JKS.

swarm.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.

swarm.management.security-realms.KEY.ssl-server-identity.protocol

The protocol to use when creating the SSLContext.

swarm.management.security-realms.KEY.truststore-authentication.keystore-password

The password to open the keystore.

swarm.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.

swarm.management.security-realms.KEY.truststore-authentication.keystore-provider

The provider for loading the keystore, defaults to JKS.

swarm.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.

swarm.management.security-realms.KEY.users-authentication.users.KEY.password

The user’s password.

6.37.1. Management Console

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>management-console</artifactId>
</dependency>
Configuration
swarm.management-console.context

Web context path of the management console

6.38. Messaging

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>messaging</artifactId>
</dependency>
Configuration
swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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'.

swarm.messaging-activemq.jms-bridges.KEY.module

The name of AS7 module containing the resources required to lookup source and target JMS resources.

swarm.messaging-activemq.jms-bridges.KEY.paused

Whether the JMS bridge is paused.

swarm.messaging-activemq.jms-bridges.KEY.quality-of-service

The desired quality of service mode (AT_MOST_ONCE, DUPLICATES_OK or ONCE_AND_ONLY_ONCE).

swarm.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.

swarm.messaging-activemq.jms-bridges.KEY.source-connection-factory

The name of the source connection factory to lookup on the source messaging server.

swarm.messaging-activemq.jms-bridges.KEY.source-context

The properties used to configure the source JNDI initial context.

swarm.messaging-activemq.jms-bridges.KEY.source-destination

The name of the source destination to lookup on the source messaging server.

swarm.messaging-activemq.jms-bridges.KEY.source-password

The password for creating the source connection.

swarm.messaging-activemq.jms-bridges.KEY.source-user

The name of the user for creating the source connection.

swarm.messaging-activemq.jms-bridges.KEY.started

Whether the JMS bridge is started.

swarm.messaging-activemq.jms-bridges.KEY.subscription-name

The name of the subscription if it is durable and the source destination is a topic.

swarm.messaging-activemq.jms-bridges.KEY.target-connection-factory

The name of the target connection factory to lookup on the target messaging server.

swarm.messaging-activemq.jms-bridges.KEY.target-context

The properties used to configure the target JNDI initial context.

swarm.messaging-activemq.jms-bridges.KEY.target-destination

The name of the target destination to lookup on the target messaging server.

swarm.messaging-activemq.jms-bridges.KEY.target-password

The password for creating the target connection.

swarm.messaging-activemq.jms-bridges.KEY.target-user

The name of the user for creating the target connection.

swarm.messaging-activemq.servers.KEY.acceptors.KEY.factory-class

Class name of the factory class that can instantiate the acceptor.

swarm.messaging-activemq.servers.KEY.acceptors.KEY.params

A key-value pair understood by the acceptor factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.acceptors.KEY.socket-binding

The socket binding that the acceptor will use to accept connections.

swarm.messaging-activemq.servers.KEY.acceptors.KEY.started

Whether this acceptor is started.

swarm.messaging-activemq.servers.KEY.active

Whether the server is active (and accepting connections) or passive (in backup mode, waiting for failover).

swarm.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)

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.dead-letter-address

The dead letter address

swarm.messaging-activemq.servers.KEY.address-settings.KEY.expiry-address

Defines where to send a message that has expired.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.expiry-delay

Defines the expiration time that will be used for messages using the default expiration time

swarm.messaging-activemq.servers.KEY.address-settings.KEY.last-value-queue

Defines whether a queue only uses last values or not

swarm.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

swarm.messaging-activemq.servers.KEY.address-settings.KEY.max-redelivery-delay

Maximum value for the redelivery-delay (in ms).

swarm.messaging-activemq.servers.KEY.address-settings.KEY.max-size-bytes

The max bytes size.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.message-counter-history-day-limit

Day limit for the message counter history.

swarm.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.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.page-size-bytes

The paging size.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.redelivery-delay

Defines how long to wait before attempting redelivery of a cancelled message

swarm.messaging-activemq.servers.KEY.address-settings.KEY.redelivery-multiplier

Multiplier to apply to the redelivery-delay parameter

swarm.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

swarm.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.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.slow-consumer-check-period

How often to check for slow consumers on a particular queue.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.slow-consumer-policy

Determine what happens when a slow consumer is identified.

swarm.messaging-activemq.servers.KEY.address-settings.KEY.slow-consumer-threshold

The minimum rate of message consumption allowed before a consumer is considered slow.

swarm.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.

swarm.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. <p>If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: </p>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.

swarm.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:<ul><li>jboss.home - the root directory of the JBoss AS distribution</li><li>user.home - user’s home directory</li><li>user.dir - user’s current working directory</li><li>java.home - java installation directory</li><li>jboss.server.base.dir - root directory for an individual server instance</li><li>jboss.server.data.dir - directory the server will use for persistent data file storage</li><li>jboss.server.log.dir - directory the server will use for log file storage</li><li>jboss.server.tmp.dir - directory the server will use for temporary file storage</li><li>jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances</li></ul>

swarm.messaging-activemq.servers.KEY.bridges.KEY.check-period

The period (in milliseconds) between client failure check.

swarm.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.

swarm.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).

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.bridges.KEY.initial-connect-attempts

The number of attempts to connect initially with this bridge.

swarm.messaging-activemq.servers.KEY.bridges.KEY.max-retry-interval

The maximum interval of time used to retry connections

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.bridges.KEY.queue-name

The unique name of the local queue that the bridge consumes from.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.bridges.KEY.started

Whether the bridge is started.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.broadcast-groups.KEY.broadcast-period

The period in milliseconds between consecutive broadcasts.

swarm.messaging-activemq.servers.KEY.broadcast-groups.KEY.connectors

Specifies the names of connectors that will be broadcast.

swarm.messaging-activemq.servers.KEY.broadcast-groups.KEY.jgroups-channel

The name used by a JGroups channel to join a cluster.

swarm.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.

swarm.messaging-activemq.servers.KEY.broadcast-groups.KEY.socket-binding

The broadcast group socket binding.

swarm.messaging-activemq.servers.KEY.broadcast-groups.KEY.started

Whether the broadcast group is started.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.call-timeout

The timeout (in ms) for remote calls made by the cluster connection.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.check-period

The period (in milliseconds) between client failure check.

swarm.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.

swarm.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.

swarm.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).

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.connector-name

The name of connector to use for live connection

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.initial-connect-attempts

The number of attempts to connect initially with this cluster connection.

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.max-retry-interval

The maximum interval of time used to retry connections

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.message-load-balancing-type

The type of message load balancing provided by the cluster connection.

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.node-id

The node ID used by this cluster connection.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.notification-attempts

How many times the cluster connection will broadcast itself

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.notification-interval

How often the cluster connection will broadcast itself

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.started

Whether the cluster connection is started.

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-connections.KEY.topology

The topology of the nodes that this cluster connection is aware of.

swarm.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.

swarm.messaging-activemq.servers.KEY.cluster-password

The password used by cluster connections to communicate between the clustered nodes.

swarm.messaging-activemq.servers.KEY.cluster-user

The user used by cluster connections to communicate between the clustered nodes.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.auto-group

Whether or not message grouping is automatically used

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.block-on-acknowledge

True to set block on acknowledge.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.block-on-durable-send

True to set block on durable send.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.block-on-non-durable-send

True to set block on non durable send.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.cache-large-message-client

True to cache large messages.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.call-failover-timeout

The timeout to use when fail over is in process (in ms).

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.call-timeout

The call time out.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.client-failure-check-period

The client failure check period.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.client-id

The client id.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.compress-large-messages

Whether large messages should be compressed.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.confirmation-window-size

The confirmation window size.

swarm.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.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.connection-ttl

The connection ttl.

swarm.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.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.consumer-max-rate

The consumer max rate.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.consumer-window-size

The consumer window size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.discovery-group

The discovery group name.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.dups-ok-batch-size

The dups ok batch size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.entries

The jndi names the connection factory should be bound to.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.factory-type

The type of connection factory.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.failover-on-initial-connection

True to fail over on initial connection.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.group-id

The group id.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.ha

Whether the connection factory supports High Availability.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.max-retry-interval

The max retry interval.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.min-large-message-size

The min large message size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.pre-acknowledge

True to pre-acknowledge.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.producer-max-rate

The producer max rate.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.producer-window-size

The producer window size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.protocol-manager-factory

The protocol manager factory used by this connection factory.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.reconnect-attempts

The reconnect attempts.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.retry-interval

The retry interval.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.retry-interval-multiplier

The retry interval multiplier.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.scheduled-thread-pool-max-size

The scheduled thread pool max size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.thread-pool-max-size

The thread pool max size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.transaction-batch-size

The transaction batch size.

swarm.messaging-activemq.servers.KEY.connection-factories.KEY.use-global-pools

True to use global pools.

swarm.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.

swarm.messaging-activemq.servers.KEY.connector-services.KEY.factory-class

Class name of the factory class that can instantiate the connector service.

swarm.messaging-activemq.servers.KEY.connector-services.KEY.params

A key/value pair understood by the connector service’s factory-class

swarm.messaging-activemq.servers.KEY.connectors.KEY.factory-class

Class name of the factory class that can instantiate the connector.

swarm.messaging-activemq.servers.KEY.connectors.KEY.params

A key-value pair understood by the connector factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.connectors.KEY.socket-binding

The socket binding that the connector will use to create connections.

swarm.messaging-activemq.servers.KEY.core-address.KEY.binding-names

The names of all bindings (both queues and diverts) bound to this address.

swarm.messaging-activemq.servers.KEY.core-address.KEY.number-of-bytes-per-page

The number of bytes used by each page for this address.

swarm.messaging-activemq.servers.KEY.core-address.KEY.number-of-pages

The number of pages used by this address.

swarm.messaging-activemq.servers.KEY.core-address.KEY.queue-names

The names of the queues associated with the address.

swarm.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.consume

his permission allows the user to consume a message from a queue bound to matching addresses.

swarm.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.create-durable-queue

This permission allows the user to create a durable queue.

swarm.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.create-non-durable-queue

This permission allows the user to create a temporary queue.

swarm.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.delete-durable-queue

This permission allows the user to delete a durable queue.

swarm.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.delete-non-durable-queue

This permission allows the user to delete a temporary queue.

swarm.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.

swarm.messaging-activemq.servers.KEY.core-address.KEY.roles.KEY.send

This permission allows the user to send a message to matching addresses.

swarm.messaging-activemq.servers.KEY.create-bindings-dir

Whether the server should create the bindings directory on start up.

swarm.messaging-activemq.servers.KEY.create-journal-dir

Whether the server should create the journal directory on start up.

swarm.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.

swarm.messaging-activemq.servers.KEY.discovery-groups.KEY.jgroups-channel

The name used by a JGroups channel to join a cluster.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.discovery-groups.KEY.socket-binding

The discovery group socket binding.

swarm.messaging-activemq.servers.KEY.diverts.KEY.divert-address

Address to divert from

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.diverts.KEY.forwarding-address

Address to divert to

swarm.messaging-activemq.servers.KEY.diverts.KEY.routing-name

Routing name of the divert

swarm.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.

swarm.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).

swarm.messaging-activemq.servers.KEY.grouping-handlers.KEY.grouping-handler-address

A reference to a cluster connection and the address it uses.

swarm.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).

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.http-acceptors.KEY.http-listener

The Undertow’s http-listener that handles HTTP upgrade requests.

swarm.messaging-activemq.servers.KEY.http-acceptors.KEY.params

A key-value pair understood by the acceptor factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.http-acceptors.KEY.upgrade-legacy

Also accepts to upgrade HTTP request from legacy (HornetQ) clients.

swarm.messaging-activemq.servers.KEY.http-connectors.KEY.endpoint

The http-acceptor that serves as the endpoint of this http-connector.

swarm.messaging-activemq.servers.KEY.http-connectors.KEY.params

A key-value pair understood by the connector factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.http-connectors.KEY.socket-binding

The socket binding that the connector will use to create connections.

swarm.messaging-activemq.servers.KEY.id-cache-size

The size of the cache for pre-creating message IDs.

swarm.messaging-activemq.servers.KEY.in-vm-acceptors.KEY.params

A key-value pair understood by the acceptor factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.in-vm-acceptors.KEY.server-id

The server id.

swarm.messaging-activemq.servers.KEY.in-vm-acceptors.KEY.started

Whether this acceptor is started.

swarm.messaging-activemq.servers.KEY.in-vm-connectors.KEY.params

A key-value pair understood by the connector factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.in-vm-connectors.KEY.server-id

The server id.

swarm.messaging-activemq.servers.KEY.incoming-interceptors

The list of incoming interceptor classes used by this server.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.consumer-count

The number of consumers consuming messages from this queue.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.dead-letter-address

The address to send dead messages to.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.delivering-count

The number of messages that this queue is currently delivering to its consumers.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.durable

Whether the queue is durable or not.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.entries

The jndi names the queue will be bound to.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.expiry-address

The address to send expired messages to.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.legacy-entries

The jndi names the queue will be bound to.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.message-count

The number of messages currently in this queue.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.messages-added

The number of messages added to this queue since it was created.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.paused

Whether the queue is paused.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.queue-address

The queue address defines what address is used for routing messages.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.scheduled-count

The number of scheduled messages in this queue.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.selector

The queue selector.

swarm.messaging-activemq.servers.KEY.jms-queues.KEY.temporary

Whether the queue is temporary.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.delivering-count

The number of messages that this queue is currently delivering to its consumers.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.durable-message-count

The number of messages for all durable subscribers for this topic.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.durable-subscription-count

The number of durable subscribers for this topic.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.entries

The jndi names the topic will be bound to.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.legacy-entries

The legacy jndi names the topic will be bound to.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.message-count

The number of messages currently in this queue.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.messages-added

The number of messages added to this queue since it was created.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.non-durable-message-count

The number of messages for all non-durable subscribers for this topic.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.non-durable-subscription-count

The number of non-durable subscribers for this topic.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.subscription-count

The number of (durable and non-durable) subscribers for this topic.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.temporary

Whether the topic is temporary.

swarm.messaging-activemq.servers.KEY.jms-topics.KEY.topic-address

The address the topic points to.

swarm.messaging-activemq.servers.KEY.jmx-domain

The JMX domain used to register internal ActiveMQ MBeans in the MBeanServer.

swarm.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.

swarm.messaging-activemq.servers.KEY.journal-buffer-size

The size of the internal buffer on the journal.

swarm.messaging-activemq.servers.KEY.journal-buffer-timeout

The timeout (in nanoseconds) used to flush internal buffers on the journal.

swarm.messaging-activemq.servers.KEY.journal-compact-min-files

The minimal number of journal data files before we can start compacting.

swarm.messaging-activemq.servers.KEY.journal-compact-percentage

The percentage of live data on which we consider compacting the journal.

swarm.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. <p>If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: </p>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.

swarm.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:<ul><li>jboss.home - the root directory of the JBoss AS distribution</li><li>user.home - user’s home directory</li><li>user.dir - user’s current working directory</li><li>java.home - java installation directory</li><li>jboss.server.base.dir - root directory for an individual server instance</li><li>jboss.server.data.dir - directory the server will use for persistent data file storage</li><li>jboss.server.log.dir - directory the server will use for log file storage</li><li>jboss.server.tmp.dir - directory the server will use for temporary file storage</li><li>jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances</li></ul>

swarm.messaging-activemq.servers.KEY.journal-file-size

The size (in bytes) of each journal file.

swarm.messaging-activemq.servers.KEY.journal-max-io

The maximum number of write requests that can be in the AIO queue at any one time.

swarm.messaging-activemq.servers.KEY.journal-min-files

How many journal files to pre-create.

swarm.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).

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.journal-type

The type of journal to use.

swarm.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. <p>If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: </p>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.

swarm.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:<ul><li>jboss.home - the root directory of the JBoss AS distribution</li><li>user.home - user’s home directory</li><li>user.dir - user’s current working directory</li><li>java.home - java installation directory</li><li>jboss.server.base.dir - root directory for an individual server instance</li><li>jboss.server.data.dir - directory the server will use for persistent data file storage</li><li>jboss.server.log.dir - directory the server will use for log file storage</li><li>jboss.server.tmp.dir - directory the server will use for temporary file storage</li><li>jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances</li></ul>

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.auto-group

Whether or not message grouping is automatically used

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.block-on-acknowledge

True to set block on acknowledge.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.block-on-durable-send

True to set block on durable send.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.block-on-non-durable-send

True to set block on non durable send.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.cache-large-message-client

True to cache large messages.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.call-failover-timeout

The timeout to use when fail over is in process (in ms).

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.call-timeout

The call time out.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.client-failure-check-period

The client failure check period.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.client-id

The client id.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.compress-large-messages

Whether large messages should be compressed.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.confirmation-window-size

The confirmation window size.

swarm.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.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.connection-ttl

The connection ttl.

swarm.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.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.consumer-max-rate

The consumer max rate.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.consumer-window-size

The consumer window size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.discovery-group

The discovery group name.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.dups-ok-batch-size

The dups ok batch size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.entries

The jndi names the connection factory should be bound to.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.factory-type

The type of connection factory.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.failover-on-initial-connection

True to fail over on initial connection.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.group-id

The group id.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.ha

Whether the connection factory supports High Availability.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.initial-connect-attempts

The number of attempts for the initial connection to the server.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.initial-message-packet-size

The initial size of messages created through this factory.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.max-retry-interval

The max retry interval.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.min-large-message-size

The min large message size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.pre-acknowledge

True to pre-acknowledge.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.producer-max-rate

The producer max rate.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.producer-window-size

The producer window size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.reconnect-attempts

The reconnect attempts.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.retry-interval

The retry interval.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.retry-interval-multiplier

The retry interval multiplier.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.scheduled-thread-pool-max-size

The scheduled thread pool max size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.thread-pool-max-size

The thread pool max size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.transaction-batch-size

The transaction batch size.

swarm.messaging-activemq.servers.KEY.legacy-connection-factories.KEY.use-global-pools

True to use global pools.

swarm.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.

swarm.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-cluster-name

Name of the cluster used to scale down.

swarm.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-connectors

List of connectors used to form the scale-down cluster.

swarm.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-discovery-group

Name of the discovery group used to build the scale-down cluster

swarm.messaging-activemq.servers.KEY.live-only-ha-policy.scale-down-group-name

Name of the group used to scale down.

swarm.messaging-activemq.servers.KEY.log-journal-write-rate

Whether to periodically log the journal’s write rate and flush rate.

swarm.messaging-activemq.servers.KEY.management-address

Address to send management messages to.

swarm.messaging-activemq.servers.KEY.management-notification-address

The name of the address that consumers bind to to receive management notifications.

swarm.messaging-activemq.servers.KEY.memory-measure-interval

Frequency to sample JVM memory in ms (or -1 to disable memory sampling)

swarm.messaging-activemq.servers.KEY.memory-warning-threshold

Percentage of available memory which if exceeded results in a warning log

swarm.messaging-activemq.servers.KEY.message-counter-max-day-history

How many days to keep message counter history.

swarm.messaging-activemq.servers.KEY.message-counter-sample-period

The sample period (in ms) to use for message counters.

swarm.messaging-activemq.servers.KEY.message-expiry-scan-period

How often (in ms) to scan for expired messages.

swarm.messaging-activemq.servers.KEY.message-expiry-thread-priority

The priority of the thread expiring messages.

swarm.messaging-activemq.servers.KEY.outgoing-interceptors

The list of outgoing interceptor classes used by this server.

swarm.messaging-activemq.servers.KEY.override-in-vm-security

Whether the ActiveMQ server will override security credentials for in-vm connections.

swarm.messaging-activemq.servers.KEY.page-max-concurrent-io

The maximum number of concurrent reads allowed on paging

swarm.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. <p>If treated as an absolute path, the actual runtime pathname specified by the value of this attribute will be determined as follows: </p>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.

swarm.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:<ul><li>jboss.home - the root directory of the JBoss AS distribution</li><li>user.home - user’s home directory</li><li>user.dir - user’s current working directory</li><li>java.home - java installation directory</li><li>jboss.server.base.dir - root directory for an individual server instance</li><li>jboss.server.data.dir - directory the server will use for persistent data file storage</li><li>jboss.server.log.dir - directory the server will use for log file storage</li><li>jboss.server.tmp.dir - directory the server will use for temporary file storage</li><li>jboss.domain.servers.dir - directory under which a host controller will create the working area for individual server instances</li></ul>

swarm.messaging-activemq.servers.KEY.perf-blast-pages

TODO

swarm.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.

swarm.messaging-activemq.servers.KEY.persist-id-cache

Whether IDs are persisted to the journal.

swarm.messaging-activemq.servers.KEY.persistence-enabled

Whether the server will use the file based journal for persistence.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.auto-group

The autogroup.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.block-on-acknowledge

True to set block on acknowledge.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.block-on-durable-send

True to set block on durable send.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.block-on-non-durable-send

True to set block on non durable send.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.cache-large-message-client

True to cache large messages.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.call-failover-timeout

The timeout to use when fail over is in process (in ms).

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.call-timeout

The call time out.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.client-failure-check-period

The client failure check period.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.client-id

The client id.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.compress-large-messages

Whether large messages should be compressed.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.confirmation-window-size

The confirmation window size.

swarm.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.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.connection-ttl

The connection ttl.

swarm.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.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.consumer-max-rate

The consumer max rate.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.consumer-window-size

The consumer window size.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.discovery-group

The discovery group name.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.dups-ok-batch-size

The dups ok batch size.

swarm.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.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.entries

The jndi names the connection factory should be bound to.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.failover-on-initial-connection

True to fail over on initial connection.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.group-id

The group id.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.ha

Whether the connection factory supports High Availability.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.initial-connect-attempts

The number of attempts to connect initially with this factory.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.initial-message-packet-size

The initial size of messages created through this factory.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.jndi-params

The JNDI params to use for locating the destination for incoming connections.

swarm.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.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.max-pool-size

The maximum size for the pool

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.max-retry-interval

The max retry interval.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.min-large-message-size

The min large message size.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.min-pool-size

The minimum size for the pool

swarm.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.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.pre-acknowledge

True to pre-acknowledge.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.producer-max-rate

The producer max rate.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.producer-window-size

The producer window size.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.protocol-manager-factory

The protocol manager factory used by this pooled connection factory.

swarm.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).

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.retry-interval

The retry interval.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.retry-interval-multiplier

The retry interval multiplier.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.scheduled-thread-pool-max-size

The scheduled thread pool max size.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.setup-attempts

The number of times to set up an MDB endpoint

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.setup-interval

The interval between attempts at setting up an MDB endpoint.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.thread-pool-max-size

The thread pool max size.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.transaction

TODO

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.transaction-batch-size

The transaction batch size.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-auto-recovery

True to use auto recovery.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-global-pools

True to use global pools.

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-jndi

Use JNDI to locate the destination for incoming connections

swarm.messaging-activemq.servers.KEY.pooled-connection-factories.KEY.use-local-tx

Use a local transaction for incoming sessions

swarm.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.

swarm.messaging-activemq.servers.KEY.queues.KEY.consumer-count

The number of consumers consuming messages from this queue.

swarm.messaging-activemq.servers.KEY.queues.KEY.dead-letter-address

The address to send the queue’s dead messages to.

swarm.messaging-activemq.servers.KEY.queues.KEY.delivering-count

The number of messages that this queue is currently delivering to its consumers.

swarm.messaging-activemq.servers.KEY.queues.KEY.durable

Defines whether the queue is durable.

swarm.messaging-activemq.servers.KEY.queues.KEY.expiry-address

The address to send the queue’s expired messages to.

swarm.messaging-activemq.servers.KEY.queues.KEY.filter

A queue message filter definition. An undefined or empty filter will match all messages.

swarm.messaging-activemq.servers.KEY.queues.KEY.id

The id of the queue.

swarm.messaging-activemq.servers.KEY.queues.KEY.message-count

The number of messages currently in this queue.

swarm.messaging-activemq.servers.KEY.queues.KEY.messages-added

The number of messages added to this queue since it was created.

swarm.messaging-activemq.servers.KEY.queues.KEY.paused

Whether the queue is paused.

swarm.messaging-activemq.servers.KEY.queues.KEY.queue-address

The queue address defines what address is used for routing messages.

swarm.messaging-activemq.servers.KEY.queues.KEY.scheduled-count

The number of scheduled messages in this queue.

swarm.messaging-activemq.servers.KEY.queues.KEY.temporary

Whether the queue is temporary.

swarm.messaging-activemq.servers.KEY.remote-acceptors.KEY.params

A key-value pair understood by the acceptor factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.remote-acceptors.KEY.socket-binding

The socket binding that the acceptor will use to accept connections.

swarm.messaging-activemq.servers.KEY.remote-acceptors.KEY.started

Whether this acceptor is started.

swarm.messaging-activemq.servers.KEY.remote-connectors.KEY.params

A key-value pair understood by the connector factory-class and used to configure it.

swarm.messaging-activemq.servers.KEY.remote-connectors.KEY.socket-binding

The socket binding that the connector will use to create connections.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.excluded-connectors

The connectors that must not have their port offset.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.master-configuration.cluster-name

Name of the cluster used for replication.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.master-configuration.initial-replication-sync-timeout

How long to wait until the initiation replication is synchronized.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.max-backups

Whether or not this live server will accept backup requests from other live servers.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.request-backup

If true then the server will request a backup on another node.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.cluster-name

Name of the cluster used for replication.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.initial-replication-sync-timeout

How long to wait until the initiation replication is synchronized.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-cluster-name

Name of the cluster used to scale down.

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-connectors

List of connectors used to form the scale-down cluster.

swarm.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

swarm.messaging-activemq.servers.KEY.replication-colocated-ha-policy.slave-configuration.scale-down-group-name

Name of the group used to scale down.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-master-ha-policy.cluster-name

Name of the cluster used for replication.

swarm.messaging-activemq.servers.KEY.replication-master-ha-policy.group-name

If set, backup servers will only pair with live servers with matching group-name.

swarm.messaging-activemq.servers.KEY.replication-master-ha-policy.initial-replication-sync-timeout

How long to wait until the initiation replication is synchronized.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.cluster-name

Name of the cluster used for replication.

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.group-name

If set, backup servers will only pair with live servers with matching group-name.

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.initial-replication-sync-timeout

How long to wait until the initiation replication is synchronized.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-cluster-name

Name of the cluster used to scale down.

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-connectors

List of connectors used to form the scale-down cluster.

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-discovery-group

Name of the discovery group used to build the scale-down cluster

swarm.messaging-activemq.servers.KEY.replication-slave-ha-policy.scale-down-group-name

Name of the group used to scale down.

swarm.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.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.consumer-count

The number of consumers consuming messages from this queue.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.dead-letter-address

The address to send the queue’s dead messages to.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.delivering-count

The number of messages that this queue is currently delivering to its consumers.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.durable

Defines whether the queue is durable.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.expiry-address

The address to send the queue’s expired messages to.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.filter

A queue message filter definition. An undefined or empty filter will match all messages.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.id

The id of the queue.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.message-count

The number of messages currently in this queue.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.messages-added

The number of messages added to this queue since it was created.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.paused

Whether the queue is paused.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.queue-address

The queue address defines what address is used for routing messages.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.scheduled-count

The number of scheduled messages in this queue.

swarm.messaging-activemq.servers.KEY.runtime-queues.KEY.temporary

Whether the queue is temporary.

swarm.messaging-activemq.servers.KEY.scheduled-thread-pool-max-size

The number of threads that the main scheduled thread pool has.

swarm.messaging-activemq.servers.KEY.security-domain

The security domain to use to verify user and role information

swarm.messaging-activemq.servers.KEY.security-enabled

Whether security is enabled.

swarm.messaging-activemq.servers.KEY.security-invalidation-interval

How long (in ms) to wait before invalidating the security cache.

swarm.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.consume

his permission allows the user to consume a message from a queue bound to matching addresses.

swarm.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.create-durable-queue

This permission allows the user to create a durable queue.

swarm.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.create-non-durable-queue

This permission allows the user to create a temporary queue.

swarm.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.delete-durable-queue

This permission allows the user to delete a durable queue.

swarm.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.delete-non-durable-queue

This permission allows the user to delete a temporary queue.

swarm.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.

swarm.messaging-activemq.servers.KEY.security-settings.KEY.roles.KEY.send

This permission allows the user to send a message to matching addresses.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.request-backup

If true then the server will request a backup on another node.

swarm.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.

swarm.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.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-cluster-name

Name of the cluster used to scale down.

swarm.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-connectors

List of connectors used to form the scale-down cluster.

swarm.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

swarm.messaging-activemq.servers.KEY.shared-store-colocated-ha-policy.slave-configuration.scale-down-group-name

Name of the group used to scale down.

swarm.messaging-activemq.servers.KEY.shared-store-master-ha-policy.failover-on-server-shutdown

Whether the server must failover when it is normally shutdown.

swarm.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.

swarm.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.failover-on-server-shutdown

Whether the server must failover when it is normally shutdown.

swarm.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.

swarm.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.

swarm.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-cluster-name

Name of the cluster used to scale down.

swarm.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-connectors

List of connectors used to form the scale-down cluster.

swarm.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

swarm.messaging-activemq.servers.KEY.shared-store-slave-ha-policy.scale-down-group-name

Name of the group used to scale down.

swarm.messaging-activemq.servers.KEY.started

Whether this server is started.

swarm.messaging-activemq.servers.KEY.statistics-enabled

Whether gathering of statistics such as message counters are enabled.

swarm.messaging-activemq.servers.KEY.thread-pool-max-size

The number of threads that the main thread pool has. -1 means no limit.

swarm.messaging-activemq.servers.KEY.transaction-timeout

How long (in ms) before a transaction can be removed from the resource manager after create time.

swarm.messaging-activemq.servers.KEY.transaction-timeout-scan-period

How often (in ms) to scan for timeout transactions.

swarm.messaging-activemq.servers.KEY.version

The server’s version.

swarm.messaging-activemq.servers.KEY.wild-card-routing-enabled

Whether the server supports wild card routing.

swarm.messaging.remote

Flag to enable the remote connection

swarm.messaging.remote.host

Host of the remote connection

swarm.messaging.remote.jndi-name

JNDI name of the remote connection

swarm.messaging.remote.name

Name of the remote connection

swarm.messaging.remote.port

Port of the remote connection

6.39. MicroProfile

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>microprofile</artifactId>
</dependency>

6.40. Modcluster

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>mod_cluster</artifactId>
</dependency>
Configuration
swarm.modcluster.configuration-mod-cluster-config.advertise

Use Advertise logic or not.

swarm.modcluster.configuration-mod-cluster-config.advertise-security-key

String containing the security key for the Advertise logic.

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

Enable contexts even if disabled in mod_cluster_manager (httpd).

swarm.modcluster.configuration-mod-cluster-config.balancer

The balancer name.

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 mod_cluster reverse proxy will connect to.

swarm.modcluster.configuration-mod-cluster-config.excluded-contexts

List of contexts mod_cluster should ignore, Format String separated with commas.

swarm.modcluster.configuration-mod-cluster-config.flush-packets

Enables/disables packet flushing in httpd.

swarm.modcluster.configuration-mod-cluster-config.flush-wait

Time to wait before flushing packets in httpd.

swarm.modcluster.configuration-mod-cluster-config.load-balancing-group

loadBalancingGroup name.

swarm.modcluster.configuration-mod-cluster-config.max-attempts

Max attempts to process an idempotent request.

swarm.modcluster.configuration-mod-cluster-config.node-timeout

Timeout (in seconds) for proxy connections to a node.

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 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

swarm.modcluster.configuration-mod-cluster-config.smax

Soft maximum idle connection count in httpd

swarm.modcluster.configuration-mod-cluster-config.socket-timeout

Timeout to wait for httpd to answer a MCMP message.

swarm.modcluster.configuration-mod-cluster-config.status-interval

Number of seconds a STATUS message is sent from the application server to the reverse proxy.

swarm.modcluster.configuration-mod-cluster-config.sticky-session

Use sticky sessions for requests.

swarm.modcluster.configuration-mod-cluster-config.sticky-session-force

Don’t failover a request with session information.

swarm.modcluster.configuration-mod-cluster-config.sticky-session-remove

Remove session information on failover.

swarm.modcluster.configuration-mod-cluster-config.stop-context-timeout

Max 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

Timeout to wait in httpd for an available worker to process the requests.

swarm.modcluster.multicast-address

Multicast address

swarm.modcluster.multicast-port

Multicast port

6.41. MongoDB

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>mongodb</artifactId>
</dependency>
Configuration
swarm.mongo-d-b.mongos.KEY.auth-type

MongoDB authorization type

swarm.mongo-d-b.mongos.KEY.database

MongoDB database name

swarm.mongo-d-b.mongos.KEY.hosts.KEY.outbound-socket-binding-ref

MongoDB target hostname/port number

swarm.mongo-d-b.mongos.KEY.id

Unique profile identification

swarm.mongo-d-b.mongos.KEY.jndi-name

JNDI address

swarm.mongo-d-b.mongos.KEY.module

Module name

swarm.mongo-d-b.mongos.KEY.properties.KEY.property

Custom MongoDB property

swarm.mongo-d-b.mongos.KEY.security-domain

Security domain name

swarm.mongo-d-b.mongos.KEY.ssl

use SSL for connecting to MongoDB

6.42. Monitor

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>monitor</artifactId>
</dependency>
Configuration
swarm.monitor.security-realm

(not yet documented)

6.43. 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>org.wildfly.swarm</groupId>
  <artifactId>msc</artifactId>
</dependency>

6.44. Naming

Provides support for JNDI.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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.45. Neo4j

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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.46. Guava

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>netflix-guava</artifactId>
</dependency>

6.47. RX-Java

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>netflix-rxjava</artifactId>
</dependency>

6.48. RX-Netty

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>netflix-rxnetty</artifactId>
</dependency>

6.49. OpenTracing

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>opentracing</artifactId>
</dependency>
Configuration
swarm.opentracing.servlet.skipPattern

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

6.50. OrientDB

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>orientdb</artifactId>
</dependency>
Configuration
swarm.orient-d-b.orients.KEY.database

Database name

swarm.orient-d-b.orients.KEY.hosts.KEY.outbound-socket-binding-ref

OrientDB target hostname/port

swarm.orient-d-b.orients.KEY.id

Unique profile identification

swarm.orient-d-b.orients.KEY.jndi-name

Database JNDI address

swarm.orient-d-b.orients.KEY.max-partition-size

Max database pool partition size

swarm.orient-d-b.orients.KEY.max-pool-size

Max database pool size

swarm.orient-d-b.orients.KEY.module

Module name

swarm.orient-d-b.orients.KEY.security-domain

Security domain name

6.51. Remoting

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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-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 (or names) of the socket binding(s) to attach to.

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 concurrent inbound messages on a channel.

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 inbound channels to support for a connection.

swarm.remoting.endpoint-configuration.max-outbound-channels

The maximum number of concurrent outbound messages on a channel.

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 outbound channels to support for a connection.

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-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.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. Defaults to http-remoting.

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)

6.52. Request Controller

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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

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.53. Resource Adapters

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>resource-adapters</artifactId>
</dependency>
Configuration
swarm.resource-adapter.resource-adapters.KEY.admin-objects.KEY.class-name

Specifies the fully qualified class name of an administration object.

swarm.resource-adapter.resource-adapters.KEY.admin-objects.KEY.config-properties.KEY.value

Custom defined config property value.

swarm.resource-adapter.resource-adapters.KEY.admin-objects.KEY.enabled

Specifies if the administration object should be enabled.

swarm.resource-adapter.resource-adapters.KEY.admin-objects.KEY.jndi-name

Specifies the JNDI name for the administration object.

swarm.resource-adapter.resource-adapters.KEY.admin-objects.KEY.use-java-context

Setting this to false will bind the object into global JNDI.

swarm.resource-adapter.resource-adapters.KEY.archive

Specifies the resource adapter archive.

swarm.resource-adapter.resource-adapters.KEY.beanvalidationgroups

Specifies the bean validation groups that should be used.

swarm.resource-adapter.resource-adapters.KEY.bootstrap-context

Specifies the unique name of the bootstrap context that should be used.

swarm.resource-adapter.resource-adapters.KEY.config-properties.KEY.value

Custom defined config property value.

swarm.resource-adapter.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.

swarm.resource-adapter.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.

swarm.resource-adapter.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.

swarm.resource-adapter.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.

swarm.resource-adapter.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.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.capacity-decrementer-class

Class defining the policy for decrementing connections in the pool

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.capacity-decrementer-properties

Properties to inject in class defining the policy for decrementing connections in the pool

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.capacity-incrementer-class

Class defining the policy for incrementing connections in the pool

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.capacity-incrementer-properties

Properties to inject in class defining the policy for incrementing connections in the pool

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.class-name

Specifies the fully qualified class name of a managed connection factory or admin object.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.config-properties.KEY.value

Custom defined config property value.

swarm.resource-adapter.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.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.enabled

Specifies if the resource adapter should be enabled.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.enlistment

Defines if lazy enlistment should be used if supported by the resource adapter.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.enlistment-trace

Defines if WildFly/IronJacamar should record enlistment traces

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.flush-strategy

Specifies how the pool should be flush in case of an error. Valid values are: FailingConnectionOnly (default), IdleConnections and EntirePool.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.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 requires a server restart..

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.initial-pool-size

TThe initial-pool-size element indicates the initial number of connections a pool should hold.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.interleaving

An element to enable interleaving for XA connections.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.jndi-name

Specifies the JNDI name for the connection factory.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.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.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.mcp

Defines the ManagedConnectionPool implementation, f.ex. org.jboss.jca.core.connectionmanager.pool.mcp.SemaphoreArrayListManagedConnectionPool

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.min-pool-size

The min-pool-size element specifies the minimum number of connections for a pool.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.no-recovery

Specifies if the connection pool should be excluded from recovery.

swarm.resource-adapter.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.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.pad-xid

Should the Xid be padded.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.pool-fair

Defines if pool should use be fair

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.pool-prefill

Should the pool be prefilled. Changing this value requires a server restart.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.pool-use-strict-min

Specifies if the min-pool-size should be considered strictly.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.recovery-password

The password used for recovery.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.recovery-plugin-class-name

The fully qualified class name of the recovery plugin implementation.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.recovery-plugin-properties

The properties for the recovery plugin.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.recovery-security-domain

The security domain used for recovery.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.recovery-username

The user name used for recovery.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.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.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.security-application

Indicates that app supplied parameters (such as from getConnection(user, pw)) are used to distinguish connections in the pool.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.security-domain

Specifies the security domain which defines the javax.security.auth.Subject that are used to distinguish connections in the pool.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.security-domain-and-application

Indicates that either app supplied parameters (such as from getConnection(user, pw)) or Subject (from security domain) are used to distinguish connections in the pool.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.sharable

Enable the use of sharable connections which allows lazy association to be enabled if supported

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.tracking

Defines if IronJacamar should track connection handles across transaction boundaries

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.use-ccm

Enable the use of a cached connection manager.

swarm.resource-adapter.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).

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.use-java-context

Setting this to false will bind the object into global JNDI.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.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.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.wrap-xa-resource

Should the XAResource instances be wrapped in an org.jboss.tm.XAResourceWrapper instance.

swarm.resource-adapter.resource-adapters.KEY.connection-definitions.KEY.xa-resource-timeout

The value is passed to XAResource.setTransactionTimeout(), in seconds. Default is zero.

swarm.resource-adapter.resource-adapters.KEY.module

Specifies the module from which resource adapter will be loaded

swarm.resource-adapter.resource-adapters.KEY.statistics-enabled

Define whether runtime statistics are enabled or not.

swarm.resource-adapter.resource-adapters.KEY.transaction-support

Specifies the transaction support level of the resource adapter.

swarm.resource-adapter.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 thei defaults.

swarm.resource-adapter.resource-adapters.KEY.wm-security-default-groups

Defines a default groups list that should be added to the used Subject instance

swarm.resource-adapter.resource-adapters.KEY.wm-security-default-principal

Defines a default principal name that should be added to the used Subject instance

swarm.resource-adapter.resource-adapters.KEY.wm-security-domain

Defines the name of the security domain that should be used

swarm.resource-adapter.resource-adapters.KEY.wm-security-mapping-groups

List of groups mappings

swarm.resource-adapter.resource-adapters.KEY.wm-security-mapping-required

Defines if a mapping is required for security credentials. A value of false means Case 1 as defined in section 16.4.3, and a value of true means Case 2 as defined in section 16.4.4.

swarm.resource-adapter.resource-adapters.KEY.wm-security-mapping-users

List of user mappings

6.54. Ribbon

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>ribbon</artifactId>
</dependency>
Configuration
swarm.deployment.KEY.ribbon.advertise

(not yet documented)

6.54.1. Ribbon Secured

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>ribbon-secured</artifactId>
</dependency>
Ribbon Secured Client
Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>ribbon-secured-client</artifactId>
</dependency>

6.55. Deployment Scanner

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>scanner</artifactId>
</dependency>

6.56. Security

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

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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.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-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.57. Servo

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>servo</artifactId>
</dependency>

6.58. Spring WebMVC

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>spring</artifactId>
</dependency>

6.59. Swagger

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>swagger</artifactId>
</dependency>
Configuration
swarm.deployment.KEY.swagger.description

(not yet documented)

swarm.deployment.KEY.swagger.host

(not yet documented)

swarm.deployment.KEY.swagger.license

(not yet documented)

swarm.deployment.KEY.swagger.license-url

(not yet documented)

swarm.deployment.KEY.swagger.packages

(not yet documented)

swarm.deployment.KEY.swagger.root

(not yet documented)

swarm.deployment.KEY.swagger.schemes

(not yet documented)

swarm.deployment.KEY.swagger.title

(not yet documented)

swarm.deployment.KEY.swagger.tos-url

(not yet documented)

swarm.deployment.KEY.swagger.version

(not yet documented)

6.59.1. Swagger Webapp

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>swagger-webapp</artifactId>
</dependency>
Configuration
swarm.swagger.web-app.context

Web context path for Swagger end point

swarm.swagger.web-app.web-content

(not yet documented)

6.60. Teiid

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</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

Thread Pool to be used with Asynchronous operations in Teiid

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

Max allowed time in milliseconds before the session is terminated by the system, 0 indicates unlimited (default 0)

swarm.teiid.authentication-trust-all-local

Allow all local pass-through connections regardless of whether they are in the configured security domain.

swarm.teiid.authentication-type

Default authentication type to use with this transport. Allowed values are (USERPASSWORD, GSS)

swarm.teiid.authorization-validator-module

Authorization Module; Implementation of org.teiid.dqp.internal.process.AuthorizationValidator class.

swarm.teiid.buffer-service-encrypt-files

Set to true to encrypt temporary data files with 128-bit AES. (default false)

swarm.teiid.buffer-service-inline-lobs

Set to true to allow inlining of memory based and small lobs into results. However inline lob values are not supported by pre-7.6 clients, so disable this property if using older clients utilizing lobs. (default true)

swarm.teiid.buffer-service-max-buffer-space

Max storage space, in MB, to be used for buffer files (default 50G)

swarm.teiid.buffer-service-max-file-size

Max File size in MB (default 2GB)

swarm.teiid.buffer-service-max-open-files

Max open buffer files (default 64)

swarm.teiid.buffer-service-max-processing-kb

The approximate amount of buffer memory in kilobytes allowable for a single processing operation (sort, grouping, etc.) regardless of existing memory commitments. -1 means to automatically calculate a value (default -1)

swarm.teiid.buffer-service-max-reserve-kb

The approximate amount of memory in kilobytes allowed to be held by the buffer manager. -1 means to automatically calculate a value (default -1)

swarm.teiid.buffer-service-max-storage-object-size

The maximum size of a buffer managed object (typically a table page or a results batch) in bytes (default 8388608 or 8MB). Setting this value too high will reduce the effectiveness of the memory buffer.

swarm.teiid.buffer-service-memory-buffer-off-heap

Set to true to hold the memory buffer off-heap. If true you must ensure that the VM can allocate that much direct memory (default false).

swarm.teiid.buffer-service-memory-buffer-space

Memory buffer space used by the buffer manager in MB. -1 determines the setting automatically from the max-reserve-kb (default -1). This value cannot be smaller than max-storage-object-size

swarm.teiid.buffer-service-processor-batch-size

The nominal row count of a batch sent internally within the query processor. The actual batch size used will depend upon the data width as well. (default 256)

swarm.teiid.buffer-service-use-disk

Use disk for buffer management

swarm.teiid.data-roles-required

WorkManager name to use in processing. (default name is "default")

swarm.teiid.detect-change-events

Set to true for the engine to detect local change events. Should be disabled if using external change data capture tools. (default true)

swarm.teiid.distributed-cache-jgroups-stack

JGroups stack name for cache replication channel

swarm.teiid.exception-on-max-source-rows

Indicates if an exception should be thrown if the specified value for Maximum Source Rows is exceeded; only up to the maximum rows will be consumed. (default true)

swarm.teiid.is-jdbc-transport-installed

(not yet documented)

swarm.teiid.jdbc.port

Set the port for the default JDBC socket listener

swarm.teiid.lob-chunk-size-in-kb

The max lob chunk size in KB transferred each time when processing blobs, clobs (100KB default)

swarm.teiid.max-active-plans

Max active plans (default 20). Increase this value on highly concurrent systems - but ensure that the underlying pools can handle the increased load without timeouts.

swarm.teiid.max-row-fetch-size

Maximum allowed fetch size, set via JDBC. User requested value ignored above this value. (default 20480)

swarm.teiid.max-source-rows-allowed

Maximum rows allowed from a source query. -1 indicates no limit. (default -1)

swarm.teiid.max-threads

Process pool maximum thread count. (default 64)

swarm.teiid.odbc.port

Set the port for the default ODBC socket listener

swarm.teiid.policy-decider-module

Policy Module; Implementation of org.teiid.PolicyDecider class

swarm.teiid.preparedplan-cache-enable

Prepared Plan cache enabled (default true)

swarm.teiid.preparedplan-cache-infinispan-container

Infinispan cache container name

swarm.teiid.preparedplan-cache-name

Infinispan cache name for prepared plans

swarm.teiid.preparser-module

Incoming SQL can be modified by an "org.teiid.PreParser"

swarm.teiid.query-threshold-in-seconds

Long running query threshold, after which a alert can be generated by tooling if configured

swarm.teiid.query-timeout

Set the default query timeout for all queries in milliseconds. 0 indicates no timeout. Lesser timeout values may be set per VDB or by clients. (default 0)

swarm.teiid.resultset-cache-enable

Resultset cache enabled (default true)

swarm.teiid.resultset-cache-infinispan-container

Infinispan cache container name

swarm.teiid.resultset-cache-max-staleness

Max staleness in seconds. Modifications are based upon data updates -1 indicates no max. (default 60 - 1 minute)

swarm.teiid.resultset-cache-name

Infinispan cache name for resultset; if not specified default cache on infinispan container is used.

swarm.teiid.runtime-version

Teiid Runtime Version

swarm.teiid.thread-count-for-source-concurrency

Max source query concurrency per user request (default 0). 0 indicates use the default calculated value based on max active plans and max threads - approximately 2*(max threads)/(max active plans).

swarm.teiid.time-slice-in-milliseconds

Query processor time slice, in milliseconds. (default 2000)

swarm.teiid.translators.KEY.module

Name of the module that implements the translator

swarm.teiid.translators.KEY.slot

Name of the module slot that implements the translator

swarm.teiid.transports.KEY.input-buffer-size

SO_RCVBUF size, 0 indicates that system default should be used (default 0)

swarm.teiid.transports.KEY.keystore-key-alias

key alias name

swarm.teiid.transports.KEY.keystore-key-password

key password

swarm.teiid.transports.KEY.keystore-name

Keystore file name

swarm.teiid.transports.KEY.keystore-password

Keystore password

swarm.teiid.transports.KEY.keystore-type

Keystore type

swarm.teiid.transports.KEY.max-socket-threads

Max number of threads dedicated to initial request processing. Zero indicates the system default of max available processors. (default 0) Setting this value above the max available processors is not recommended.

swarm.teiid.transports.KEY.output-buffer-size

SO_SNDBUF size, 0 indicates that system default should be used (default 0)

swarm.teiid.transports.KEY.pg-max-lob-size-in-bytes

Max LOB size in Postgres protocol, as streaming is not supported

swarm.teiid.transports.KEY.protocol

Transport protocol (allowed=teiid, pg)

swarm.teiid.transports.KEY.socket-binding

Socket binding to be used for the transport

swarm.teiid.transports.KEY.ssl-authentication-mode

Authentication Mode (1-way, 2-way, anonymous)

swarm.teiid.transports.KEY.ssl-enabled-cipher-suites

Comma separated cipher suites that are allowed to be used for SSL. Use to restrict encryption strength(128 bit, 256 bit). Only provide encryption suites that are supported by the server JVM. ex:SSL_RSA_WITH_RC4_128_MD5, SSL_RSA_WITH_RC4_128_SHA, SSL_RSA_WITH_3DES_EDE_CBC_SHA, SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA, SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA, TLS_DHE_RSA_WITH_AES_128_CBC_SHA, TLS_DHE_DSS_WITH_AES_128_CBC_SHA, TLS_KRB5_WITH_RC4_128_MD5, TLS_KRB5_WITH_RC4_128_SHA, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_KRB5_WITH_3DES_EDE_CBC_MD5, TLS_KRB5_WITH_3DES_EDE_CBC_SHA, TLS_DHE_RSA_WITH_AES_256_CBC_SHA, TLS_DHE_DSS_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_256_CBC_SHA

swarm.teiid.transports.KEY.ssl-keymanagement-algorithm

Use key management algorithm

swarm.teiid.transports.KEY.ssl-mode

can be one of disabled, login, or enabled disabled = no transport or message level security will be used; login = only the login traffic will be encrypted at a message level using 128 bit AES with an ephemerial DH key exchange. No other config values are needed in this mode; and it only applies to the JDBC transport enabled = traffic will be secured using this configuration, if the client supports SSL

swarm.teiid.transports.KEY.ssl-ssl-protocol

SSL protocol used

swarm.teiid.transports.KEY.truststore-check-expired

Truststore check expired

swarm.teiid.transports.KEY.truststore-name

Truststore file name

swarm.teiid.transports.KEY.truststore-password

Truststore password

swarm.teiid.workmanager

WorkManager name to use in processing. (default name is "default")

6.61. Topology

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>topology</artifactId>
</dependency>

6.61.1. Hashicorp Consul

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>topology-consul</artifactId>
</dependency>
Configuration
swarm.topology.consul.url

URL of the Consul server

6.61.2. JGroups Topology

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>topology-jgroups</artifactId>
</dependency>

6.61.3. OpenShift

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>topology-openshift</artifactId>
</dependency>

6.61.4. Topology UI

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>topology-webapp</artifactId>
</dependency>
Configuration
swarm.topology.web-app.expose-topology-endpoint

Flag to enable or disable the topology web endpoint

swarm.topology.web-app.proxied-service-mappings

Service name to URL path proxy mappings

6.62. Transactions

Provides support for the Java Transaction API (JTA) according to JSR-907.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>transactions</artifactId>
</dependency>
Configuration
swarm.transactions.commit-markable-resources.KEY.batch-size

Batch size for this CMR resource

swarm.transactions.commit-markable-resources.KEY.immediate-cleanup

Immediate cleanup associated to this CMR resource

swarm.transactions.commit-markable-resources.KEY.jndi-name

JNDi name of this CMR resource

swarm.transactions.commit-markable-resources.KEY.name

table name for storing XIDs

swarm.transactions.default-timeout

The default timeout.

swarm.transactions.enable-tsm-status

Whether the transaction status manager (TSM) service, needed for out of process recovery, should be provided or not..

swarm.transactions.jdbc-action-store-drop-table

Configure if jdbc action store should drop tables. Default is false. The server should be restarted for this setting to take effect.

swarm.transactions.jdbc-action-store-table-prefix

Optional prefix for table used to write transcation logs in configured jdbc action store. The server should be restarted for this setting to take effect.

swarm.transactions.jdbc-communication-store-drop-table

Configure if jdbc communication store should drop tables. Default is false. The server should be restarted for this setting to take effect.

swarm.transactions.jdbc-communication-store-table-prefix

Optional prefix for table used to write transcation logs in configured jdbc communication store. The server should be restarted for this setting to take effect.

swarm.transactions.jdbc-state-store-drop-table

Configure if jdbc state store should drop tables. Default is false. The server should be restarted for this setting to take effect.

swarm.transactions.jdbc-state-store-table-prefix

Optional prefix for table used to write transcation logs in configured jdbc state store. The server should be restarted for this setting to take effect.

swarm.transactions.jdbc-store-datasource

Jndi name of non-XA datasource used. Datasource sghould be define in datasources subsystem. The server should be restarted for this setting to take effect.

swarm.transactions.journal-store-enable-async-io

Whether AsyncIO should be enabled for the journal store. Default is false. The server should be restarted for this setting to take effect.

swarm.transactions.jts

If true this enables the Java Transaction Service.

swarm.transactions.log-store.expose-all-logs

Whether to expose all logs like orphans etc. By default only a subset of transaction logs is exposed.

swarm.transactions.log-store.transactions.KEY.age-in-seconds

The time since this transaction was prepared or when the recovery system last tried to recover it.

swarm.transactions.log-store.transactions.KEY.id

The id of this transaction.

swarm.transactions.log-store.transactions.KEY.jmx-name

The JMX name of this transaction.

swarm.transactions.log-store.transactions.KEY.participants.KEY.eis-product-name

The JCA enterprise information system’s product name.

swarm.transactions.log-store.transactions.KEY.participants.KEY.eis-product-version

The JCA enterprise information system’s product version

swarm.transactions.log-store.transactions.KEY.participants.KEY.jmx-name

The JMX name of this participant.

swarm.transactions.log-store.transactions.KEY.participants.KEY.jndi-name

JNDI name of this participant.

swarm.transactions.log-store.transactions.KEY.participants.KEY.status

Reports the commitment status of this participant (can be one of Pending, Prepared, Failed, Heuristic or Readonly).

swarm.transactions.log-store.transactions.KEY.participants.KEY.type

The type name under which this record is stored.

swarm.transactions.log-store.transactions.KEY.type

The type name under which this record is stored.

swarm.transactions.log-store.type

Specifies the implementation type of the logging store.

swarm.transactions.node-identifier

Used to set the node identifier on the core environment.

swarm.transactions.number-of-aborted-transactions

The number of aborted (i.e. rolledback) transactions.

swarm.transactions.number-of-application-rollbacks

The number of transactions that have been rolled back by application request. This includes those that timeout, since the timeout behavior is considered an attribute of the application configuration.

swarm.transactions.number-of-committed-transactions

The number of committed transactions.

swarm.transactions.number-of-heuristics

The number of transactions which have terminated with heuristic outcomes.

swarm.transactions.number-of-inflight-transactions

The number of transactions that have begun but not yet terminated.

swarm.transactions.number-of-nested-transactions

The total number of nested (sub) transactions created.

swarm.transactions.number-of-resource-rollbacks

The number of transactions that rolled back due to resource (participant) failure.

swarm.transactions.number-of-timed-out-transactions

The number of transactions that have rolled back due to timeout.

swarm.transactions.number-of-transactions

The total number of transactions (top-level and nested) created

swarm.transactions.object-store-path

Denotes a relative or absolute filesystem path denoting where the transaction manager object store should store data. By default the value is treated as relative to the path denoted by the "relative-to" attribute.

swarm.transactions.object-store-relative-to

References a global path configuration in the domain model, defaulting to the JBoss Application Server data directory (jboss.server.data.dir). The value of the "path" attribute will treated as relative to this path. Use an empty string to disable the default behavior and force the value of the "path" attribute to be treated as an absolute path.

swarm.transactions.port

Port for transaction manager

swarm.transactions.process-id-socket-binding

The name of the socket binding configuration to use if the transaction manager should use a socket-based process id. Will be 'undefined' if 'process-id-uuid' is 'true'; otherwise must be set.

swarm.transactions.process-id-socket-max-ports

The maximum number of ports to search for an open port if the transaction manager should use a socket-based process id. If the port specified by the socket binding referenced in 'process-id-socket-binding' is occupied, the next higher port will be tried until an open port is found or the number of ports specified by this attribute have been tried. Will be 'undefined' if 'process-id-uuid' is 'true'.

swarm.transactions.process-id-uuid

Indicates whether the transaction manager should use a UUID based process id.

swarm.transactions.recovery-listener

Used to specify if the recovery system should listen on a network socket or not.

swarm.transactions.socket-binding

Used to reference the correct socket binding to use for the recovery environment.

swarm.transactions.statistics-enabled

Whether statistics should be enabled.

swarm.transactions.status-port

Status port for transaction manager

swarm.transactions.status-socket-binding

Used to reference the correct socket binding to use for the transaction status manager.

swarm.transactions.use-jdbc-store

Use the jdbc store for writing transaction logs. Set to true to enable and to false to use the default log store type. The default log store is normally one file system file per transaction log. The server should be restarted for this setting to take effect. It’s alternative to Horneq based store

swarm.transactions.use-journal-store

Use the journal store for writing transaction logs. Set to true to enable and to false to use the default log store type. The default log store is normally one file system file per transaction log. The server should be restarted for this setting to take effect. It’s alternative to jdbc based store.

6.63. Undertow

Provides basic HTTP support, including Java Servlets, JavaServer Pages (JSP), and JavaServer Pages Standard Tag Library (JSTL) according to JSR-340, JSR-245 and JSR-52.

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>undertow</artifactId>
</dependency>
Configuration
swarm.ajp.enable

Determine if AJP should be enabled

swarm.ajp.port

Set the port for the default AJP listener

swarm.deployment

Map of security configuration by deployment

swarm.http.port

Set the port for the default HTTP listener

swarm.https.certificate.generate

Should a self-signed certificate be generated

swarm.https.certificate.generate.host

Hostname for the generated self-signed certificate

swarm.https.keystore.embedded

Should an embedded keystore be created

swarm.https.only

Only enable the HTTPS Listener

swarm.https.port

Set the port for the default HTTPS listener

swarm.undertow.alias

Alias to the server certificate key entry in the keystore

swarm.undertow.buffer-caches.KEY.buffer-size

The size of an individual buffer, in bytes.

swarm.undertow.buffer-caches.KEY.buffers-per-region

The numbers of buffers in a region

swarm.undertow.buffer-caches.KEY.max-regions

The maximum number of regions

swarm.undertow.default-security-domain

The default security domain used by web deployments

swarm.undertow.default-server

The default server to use for deployments

swarm.undertow.default-servlet-container

The default servlet container to use for deployments

swarm.undertow.default-virtual-host

The default virtual host to use for deployments

swarm.undertow.filter-configuration.custom-filters.KEY.class-name

Class name of HttpHandler

swarm.undertow.filter-configuration.custom-filters.KEY.module

Module name where class can be loaded from

swarm.undertow.filter-configuration.custom-filters.KEY.parameters

Filter parameters

swarm.undertow.filter-configuration.error-pages.KEY.code

Error page code

swarm.undertow.filter-configuration.error-pages.KEY.path

Error page path

swarm.undertow.filter-configuration.expression-filters.KEY.expression

The expression that defines the filter

swarm.undertow.filter-configuration.expression-filters.KEY.module

Module to use to load the filter definitions

swarm.undertow.filter-configuration.mod-clusters.KEY.advertise-frequency

The frequency (in milliseconds) that mod-cluster advertises itself on the network

swarm.undertow.filter-configuration.mod-clusters.KEY.advertise-path

The path that mod-cluster is registered under, defaults to /

swarm.undertow.filter-configuration.mod-clusters.KEY.advertise-protocol

The protocol that is in use, defaults to HTTP

swarm.undertow.filter-configuration.mod-clusters.KEY.advertise-socket-binding

The multicast group that is used to advertise

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.max-attempts

The number of attempts to send the request to a backend server

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.aliases

The nodes aliases

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.cache-connections

The number of connections to keep alive indefinitely

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.contexts.KEY.requests

The number of requests against this context

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.contexts.KEY.status

The status of this context

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.elected

The elected count

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.flush-packets

If received data should be immediately flushed

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.load

The current load of this node

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.load-balancing-group

The load balancing group this node belongs to

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.max-connections

The maximum number of connections per IO thread

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.open-connections

The current number of open connections

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.ping

The nodes ping

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.queue-new-requests

If a request is received and there is no worker immediately available should it be queued

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.read

The number of bytes read from the node

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.request-queue-size

The size of the request queue

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.status

The current status of this node

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.timeout

The request timeout

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.ttl

The time connections will stay alive with no requests before being closed, if the number of connections is larger than cache-connections

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.uri

The URI that the load balancer uses to connect to the node

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.nodes.KEY.written

The number of bytes transferred to the node

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.sticky-session

If sticky sessions are enabled

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.sticky-session-cookie

The session cookie name

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.sticky-session-force

If this is true then an error will be returned if the request cannot be routed to the sticky node, otherwise it will be routed to another node

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.sticky-session-path

The path of the sticky session cookie

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.sticky-session-remove

Remove the session cookie if the request cannot be routed to the correct host

swarm.undertow.filter-configuration.mod-clusters.KEY.balancers.KEY.wait-worker

The number of seconds to wait for an available worker

swarm.undertow.filter-configuration.mod-clusters.KEY.broken-node-timeout

The amount of time that must elapse before a broken node is removed from the table

swarm.undertow.filter-configuration.mod-clusters.KEY.cached-connections-per-thread

The number of connections that will be kept alive indefinitely

swarm.undertow.filter-configuration.mod-clusters.KEY.connection-idle-timeout

The amount of time a connection can be idle before it will be closed. Connections will not time out once the pool size is down to the configured minimum (as configured by cached-connections-per-thread)

swarm.undertow.filter-configuration.mod-clusters.KEY.connections-per-thread

The number of connections that will be maintained to backend servers, per IO thread. Defaults to 10.

swarm.undertow.filter-configuration.mod-clusters.KEY.enable-http2

If the load balancer should attempt to upgrade back end connections to HTTP2. If HTTP2 is not supported HTTP or HTTPS will be used as normal

swarm.undertow.filter-configuration.mod-clusters.KEY.health-check-interval

The frequency of health check pings to backend nodes

swarm.undertow.filter-configuration.mod-clusters.KEY.http2-enable-push

If push should be enabled for HTTP/2 connections

swarm.undertow.filter-configuration.mod-clusters.KEY.http2-header-table-size

The size of the header table used for HPACK compression, in bytes. This amount of memory will be allocated per connection for compression. Larger values use more memory but may give better compression.

swarm.undertow.filter-configuration.mod-clusters.KEY.http2-initial-window-size

The flow control window size that controls how quickly the client can send data to the server

swarm.undertow.filter-configuration.mod-clusters.KEY.http2-max-concurrent-streams

The maximum number of HTTP/2 streams that can be active at any time on a single connection

swarm.undertow.filter-configuration.mod-clusters.KEY.http2-max-frame-size

The max HTTP/2 frame size

swarm.undertow.filter-configuration.mod-clusters.KEY.http2-max-header-list-size

The maximum size of request headers the server is prepared to accept

swarm.undertow.filter-configuration.mod-clusters.KEY.management-access-predicate

A predicate that is applied to incoming requests to determine if they can perform mod cluster management commands. Provides additional security on top of what is provided by limiting management to requests that originate from the management-socket-binding

swarm.undertow.filter-configuration.mod-clusters.KEY.management-socket-binding

The socket binding of the mod_cluster management port. When using mod_cluster two HTTP listeners should be defined, a public one to handle requests, and one bound to the internal network to handle mod cluster commands. This socket binding should correspond to the internal listener, and should not be publicly accessible

swarm.undertow.filter-configuration.mod-clusters.KEY.max-ajp-packet-size

The maximum size for AJP packets. Increasing this will allow AJP to work for requests/responses that have a large amount of headers. This is an advanced option, and must be the same between load balancers and backend servers.

swarm.undertow.filter-configuration.mod-clusters.KEY.max-request-time

The max amount of time that a request to a backend node can take before it is killed

swarm.undertow.filter-configuration.mod-clusters.KEY.request-queue-size

The number of requests that can be queued if the connection pool is full before requests are rejected with a 503

swarm.undertow.filter-configuration.mod-clusters.KEY.security-key

The security key that is used for the mod-cluster group. All members must use the same security key.

swarm.undertow.filter-configuration.mod-clusters.KEY.security-realm

The security realm that provides the SSL configuration

swarm.undertow.filter-configuration.mod-clusters.KEY.use-alias

If an alias check is performed

swarm.undertow.filter-configuration.mod-clusters.KEY.worker

The XNIO worker that is used to send the advertise notifications

swarm.undertow.filter-configuration.request-limits.KEY.max-concurrent-requests

Maximum number of concurrent requests

swarm.undertow.filter-configuration.request-limits.KEY.queue-size

Number of requests to queue before they start being rejected

swarm.undertow.filter-configuration.response-headers.KEY.header-name

Header name

swarm.undertow.filter-configuration.response-headers.KEY.header-value

Value for header

swarm.undertow.filter-configuration.rewrites.KEY.redirect

If this is true then a redirect will be done instead of a rewrite

swarm.undertow.filter-configuration.rewrites.KEY.target

The expression that defines the target. If you are redirecting to a constant target put single quotes around the value

swarm.undertow.handler-configuration.files.KEY.cache-buffer-size

Size of the buffers, in bytes.

swarm.undertow.handler-configuration.files.KEY.cache-buffers

Number of buffers

swarm.undertow.handler-configuration.files.KEY.case-sensitive

Use case sensitive file handling

swarm.undertow.handler-configuration.files.KEY.directory-listing

Enable directory listing?

swarm.undertow.handler-configuration.files.KEY.follow-symlink

Enable following symbolic links

swarm.undertow.handler-configuration.files.KEY.path

Path on filesystem from where file handler will serve resources

swarm.undertow.handler-configuration.files.KEY.safe-symlink-paths

Paths that are safe to be targets of symbolic links

swarm.undertow.handler-configuration.reverse-proxies.KEY.cached-connections-per-thread

The number of connections that will be kept alive indefinitely

swarm.undertow.handler-configuration.reverse-proxies.KEY.connection-idle-timeout

The amount of time a connection can be idle before it will be closed. Connections will not time out once the pool size is down to the configured minimum (as configured by cached-connections-per-thread)

swarm.undertow.handler-configuration.reverse-proxies.KEY.connections-per-thread

The number of connections that will be maintained to backend servers, per IO thread. Defaults to 10.

swarm.undertow.handler-configuration.reverse-proxies.KEY.hosts.KEY.instance-id

The instance id (aka JVM route) that will be used to enable sticky sessions

swarm.undertow.handler-configuration.reverse-proxies.KEY.hosts.KEY.outbound-socket-binding

Outbound socket binding for this host

swarm.undertow.handler-configuration.reverse-proxies.KEY.hosts.KEY.path

Optional path if host is using non root resource

swarm.undertow.handler-configuration.reverse-proxies.KEY.hosts.KEY.scheme

What kind of scheme is used

swarm.undertow.handler-configuration.reverse-proxies.KEY.hosts.KEY.security-realm

The security realm that provides the SSL configuration for the connection to the host

swarm.undertow.handler-configuration.reverse-proxies.KEY.max-request-time

The maximum time that a proxy request can be active for, before being killed. Defaults to unlimited

swarm.undertow.handler-configuration.reverse-proxies.KEY.problem-server-retry

Time in seconds to wait before attempting to reconnect to a server that is down

swarm.undertow.handler-configuration.reverse-proxies.KEY.request-queue-size

The number of requests that can be queued if the connection pool is full before requests are rejected with a 503

swarm.undertow.handler-configuration.reverse-proxies.KEY.session-cookie-names

Comma separated list of session cookie names. Generally this will just be JSESSIONID.

swarm.undertow.instance-id

The cluster instance id

swarm.undertow.key-password

Password to the server certificate

swarm.undertow.keystore-password

Password to the server keystore

swarm.undertow.keystore-path

Path to the server keystore

swarm.undertow.servers.KEY.ajp-listeners.KEY.allow-encoded-slash

If a request comes in with encoded / characters (i.e. %2F), will these be decoded.

swarm.undertow.servers.KEY.ajp-listeners.KEY.allow-equals-in-cookie-value

If this is true then Undertow will allow non-escaped equals characters in unquoted cookie values. Unquoted cookie values may not contain equals characters. If present the value ends before the equals sign. The remainder of the cookie value will be dropped.

swarm.undertow.servers.KEY.ajp-listeners.KEY.always-set-keep-alive

If this is true then a Connection: keep-alive header will be added to responses, even when it is not strictly required by the specification.

swarm.undertow.servers.KEY.ajp-listeners.KEY.buffer-pipelined-data

If we should buffer pipelined requests.

swarm.undertow.servers.KEY.ajp-listeners.KEY.buffer-pool

The listeners buffer pool

swarm.undertow.servers.KEY.ajp-listeners.KEY.bytes-received

The number of bytes that have been received by this listener

swarm.undertow.servers.KEY.ajp-listeners.KEY.bytes-sent

The number of bytes that have been sent out on this listener

swarm.undertow.servers.KEY.ajp-listeners.KEY.decode-url

If this is true then the parser will decode the URL and query parameters using the selected character encoding (UTF-8 by default). If this is false they will not be decoded. This will allow a later handler to decode them into whatever charset is desired.

swarm.undertow.servers.KEY.ajp-listeners.KEY.disallowed-methods

A comma separated list of HTTP methods that are not allowed

swarm.undertow.servers.KEY.ajp-listeners.KEY.enabled

If the listener is enabled

swarm.undertow.servers.KEY.ajp-listeners.KEY.error-count

The number of 500 responses that have been sent by this listener

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-ajp-packet-size

The maximum supported size of AJP packets. If this is modified it has to be increased on the load balancer and the backend server.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-buffered-request-size

Maximum size of a buffered request, in bytes. Requests are not usually buffered, the most common case is when performing SSL renegotiation for a POST request, and the post data must be fully buffered in order to perform the renegotiation.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-connections

The maximum number of concurrent connections. Only values greater than 0 are allowed. For unlimited connections simply undefine this attribute value.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-cookies

The maximum number of cookies that will be parsed. This is used to protect against hash vulnerabilities.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-header-size

The maximum size of a http request header, in bytes.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-headers

The maximum number of headers that will be parsed. This is used to protect against hash vulnerabilities.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-parameters

The maximum number of parameters that will be parsed. This is used to protect against hash vulnerabilities. This applies to both query parameters, and to POST data, but is not cumulative (i.e. you can potentially have max parameters * 2 total parameters).

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-post-size

The maximum size of a post that will be accepted, in bytes.

swarm.undertow.servers.KEY.ajp-listeners.KEY.max-processing-time

The maximum processing time taken by a request on this listener

swarm.undertow.servers.KEY.ajp-listeners.KEY.no-request-timeout

The length of time in milliseconds that the connection can be idle before it is closed by the container, defaults to 60000 (one minute)

swarm.undertow.servers.KEY.ajp-listeners.KEY.processing-time

The total processing time of all requests handed by this listener

swarm.undertow.servers.KEY.ajp-listeners.KEY.read-timeout

Configure a read timeout for a socket, in milliseconds. If the given amount of time elapses without a successful read taking place, the socket’s next read will throw a {@link ReadTimeoutException}.

swarm.undertow.servers.KEY.ajp-listeners.KEY.receive-buffer

The receive buffer size, in bytes.

swarm.undertow.servers.KEY.ajp-listeners.KEY.record-request-start-time

If this is true then Undertow will record the request start time, to allow for request time to be logged. This has a small but measurable performance impact

swarm.undertow.servers.KEY.ajp-listeners.KEY.redirect-socket

If this listener is supporting non-SSL requests, and a request is received for which a matching <security-constraint> requires SSL transport, undertow will automatically redirect the request to the socket binding port specified here.

swarm.undertow.servers.KEY.ajp-listeners.KEY.request-count

The number of requests this listener has served

swarm.undertow.servers.KEY.ajp-listeners.KEY.request-parse-timeout

The maximum amount of time (in milliseconds) that can be spent parsing the request

swarm.undertow.servers.KEY.ajp-listeners.KEY.resolve-peer-address

Enables host dns lookup

swarm.undertow.servers.KEY.ajp-listeners.KEY.scheme

The listener scheme, can be HTTP or HTTPS. By default the scheme will be taken from the incoming AJP request.

swarm.undertow.servers.KEY.ajp-listeners.KEY.secure

If this is true then requests that originate from this listener are marked as secure, even if the request is not using HTTPS.

swarm.undertow.servers.KEY.ajp-listeners.KEY.send-buffer

The send buffer size, in bytes.

swarm.undertow.servers.KEY.ajp-listeners.KEY.socket-binding

The listener socket binding

swarm.undertow.servers.KEY.ajp-listeners.KEY.tcp-backlog

Configure a server with the specified backlog.

swarm.undertow.servers.KEY.ajp-listeners.KEY.tcp-keep-alive

Configure a channel to send TCP keep-alive messages in an implementation-dependent manner.

swarm.undertow.servers.KEY.ajp-listeners.KEY.url-charset

URL charset

swarm.undertow.servers.KEY.ajp-listeners.KEY.worker

The listeners XNIO worker

swarm.undertow.servers.KEY.ajp-listeners.KEY.write-timeout

Configure a write timeout for a socket, in milliseconds. If the given amount of time elapses without a successful write taking place, the socket’s next write will throw a {@link WriteTimeoutException}.

swarm.undertow.servers.KEY.default-host

The servers default virtual host

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.directory

Directory in which to save logs

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.extended

If the log uses the extended log file format

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.pattern

The access log pattern.

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.predicate

Predicate that determines if the request should be logged

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.prefix

Prefix for the log file name.

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.relative-to

The directory the path is relative to

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.rotate

Rotate the access log every day.

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.suffix

Suffix for the log file name.

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.use-server-log

If the log should be written to the server log, rather than a separate file. Defaults to false.

swarm.undertow.servers.KEY.hosts.KEY.access-log-setting.worker

Name of the worker to use for logging

swarm.undertow.servers.KEY.hosts.KEY.alias

Aliases for the host

swarm.undertow.servers.KEY.hosts.KEY.default-response-code

If set, this will be response code sent back in case requested context does not exist on server.

swarm.undertow.servers.KEY.hosts.KEY.default-web-module

Default web module

swarm.undertow.servers.KEY.hosts.KEY.disable-console-redirect

if set to true, /console redirect wont be enabled for this host, default is false

swarm.undertow.servers.KEY.hosts.KEY.filter-refs.KEY.predicate

Predicates provide a simple way of making a true/false decision based on an exchange. Many handlers have a requirement that they be applied conditionally, and predicates provide a general way to specify a condition.

swarm.undertow.servers.KEY.hosts.KEY.filter-refs.KEY.priority

Defines filter order, it should be set to 1 or more, higher number instructs server to be included earlier in handler chain than others under same context.

swarm.undertow.servers.KEY.hosts.KEY.locations.KEY.filter-refs.KEY.predicate

Predicates provide a simple way of making a true/false decision based on an exchange. Many handlers have a requirement that they be applied conditionally, and predicates provide a general way to specify a condition.

swarm.undertow.servers.KEY.hosts.KEY.locations.KEY.filter-refs.KEY.priority

Defines filter order, it should be set to 1 or more, higher number instructs server to be included earlier in handler chain than others under same context.

swarm.undertow.servers.KEY.hosts.KEY.locations.KEY.handler

Default handler for this location

swarm.undertow.servers.KEY.hosts.KEY.single-sign-on-setting.cookie-name

Name of the cookie

swarm.undertow.servers.KEY.hosts.KEY.single-sign-on-setting.domain

The cookie domain that will be used.

swarm.undertow.servers.KEY.hosts.KEY.single-sign-on-setting.http-only

Set Cookie httpOnly attribute.

swarm.undertow.servers.KEY.hosts.KEY.single-sign-on-setting.path

Cookie path.

swarm.undertow.servers.KEY.hosts.KEY.single-sign-on-setting.secure

Set Cookie secure attribute.

swarm.undertow.servers.KEY.http-listeners.KEY.allow-encoded-slash

If a request comes in with encoded / characters (i.e. %2F), will these be decoded.

swarm.undertow.servers.KEY.http-listeners.KEY.allow-equals-in-cookie-value

If this is true then Undertow will allow non-escaped equals characters in unquoted cookie values. Unquoted cookie values may not contain equals characters. If present the value ends before the equals sign. The remainder of the cookie value will be dropped.

swarm.undertow.servers.KEY.http-listeners.KEY.always-set-keep-alive

If this is true then a Connection: keep-alive header will be added to responses, even when it is not strictly required by the specification.

swarm.undertow.servers.KEY.http-listeners.KEY.buffer-pipelined-data

If we should buffer pipelined requests.

swarm.undertow.servers.KEY.http-listeners.KEY.buffer-pool

The listeners buffer pool

swarm.undertow.servers.KEY.http-listeners.KEY.bytes-received

The number of bytes that have been received by this listener

swarm.undertow.servers.KEY.http-listeners.KEY.bytes-sent

The number of bytes that have been sent out on this listener

swarm.undertow.servers.KEY.http-listeners.KEY.certificate-forwarding

If certificate forwarding should be enabled. If this is enabled then the listener will take the certificate from the SSL_CLIENT_CERT attribute. This should only be enabled if behind a proxy, and the proxy is configured to always set these headers.

swarm.undertow.servers.KEY.http-listeners.KEY.decode-url

If this is true then the parser will decode the URL and query parameters using the selected character encoding (UTF-8 by default). If this is false they will not be decoded. This will allow a later handler to decode them into whatever charset is desired.

swarm.undertow.servers.KEY.http-listeners.KEY.disallowed-methods

A comma separated list of HTTP methods that are not allowed

swarm.undertow.servers.KEY.http-listeners.KEY.enable-http2

Enables HTTP2 support for this listener

swarm.undertow.servers.KEY.http-listeners.KEY.enabled

If the listener is enabled

swarm.undertow.servers.KEY.http-listeners.KEY.error-count

The number of 500 responses that have been sent by this listener

swarm.undertow.servers.KEY.http-listeners.KEY.http2-enable-push

If server push is enabled for this connection

swarm.undertow.servers.KEY.http-listeners.KEY.http2-header-table-size

The size of the header table used for HPACK compression, in bytes. This amount of memory will be allocated per connection for compression. Larger values use more memory but may give better compression.

swarm.undertow.servers.KEY.http-listeners.KEY.http2-initial-window-size

The flow control window size that controls how quickly the client can send data to the server

swarm.undertow.servers.KEY.http-listeners.KEY.http2-max-concurrent-streams

The maximum number of HTTP/2 streams that can be active at any time on a single connection

swarm.undertow.servers.KEY.http-listeners.KEY.http2-max-frame-size

The max HTTP/2 frame size

swarm.undertow.servers.KEY.http-listeners.KEY.http2-max-header-list-size

The maximum size of request headers the server is prepared to accept

swarm.undertow.servers.KEY.http-listeners.KEY.max-buffered-request-size

Maximum size of a buffered request, in bytes. Requests are not usually buffered, the most common case is when performing SSL renegotiation for a POST request, and the post data must be fully buffered in order to perform the renegotiation.

swarm.undertow.servers.KEY.http-listeners.KEY.max-connections

The maximum number of concurrent connections. Only values greater than 0 are allowed. For unlimited connections simply undefine this attribute value.

swarm.undertow.servers.KEY.http-listeners.KEY.max-cookies

The maximum number of cookies that will be parsed. This is used to protect against hash vulnerabilities.

swarm.undertow.servers.KEY.http-listeners.KEY.max-header-size

The maximum size of a http request header, in bytes.

swarm.undertow.servers.KEY.http-listeners.KEY.max-headers

The maximum number of headers that will be parsed. This is used to protect against hash vulnerabilities.

swarm.undertow.servers.KEY.http-listeners.KEY.max-parameters

The maximum number of parameters that will be parsed. This is used to protect against hash vulnerabilities. This applies to both query parameters, and to POST data, but is not cumulative (i.e. you can potentially have max parameters * 2 total parameters).

swarm.undertow.servers.KEY.http-listeners.KEY.max-post-size

The maximum size of a post that will be accepted, in bytes.

swarm.undertow.servers.KEY.http-listeners.KEY.max-processing-time

The maximum processing time taken by a request on this listener

swarm.undertow.servers.KEY.http-listeners.KEY.no-request-timeout

The length of time in milliseconds that the connection can be idle before it is closed by the container, defaults to 60000 (one minute)

swarm.undertow.servers.KEY.http-listeners.KEY.processing-time

The total processing time of all requests handed by this listener

swarm.undertow.servers.KEY.http-listeners.KEY.proxy-address-forwarding

enables x-forwarded-host and similar headers and set a remote ip address and hostname

swarm.undertow.servers.KEY.http-listeners.KEY.read-timeout

Configure a read timeout for a socket, in milliseconds. If the given amount of time elapses without a successful read taking place, the socket’s next read will throw a {@link ReadTimeoutException}.

swarm.undertow.servers.KEY.http-listeners.KEY.receive-buffer

The receive buffer size, in bytes.

swarm.undertow.servers.KEY.http-listeners.KEY.record-request-start-time

If this is true then Undertow will record the request start time, to allow for request time to be logged. This has a small but measurable performance impact

swarm.undertow.servers.KEY.http-listeners.KEY.redirect-socket

If this listener is supporting non-SSL requests, and a request is received for which a matching <security-constraint> requires SSL transport, undertow will automatically redirect the request to the socket binding port specified here.

swarm.undertow.servers.KEY.http-listeners.KEY.request-count

The number of requests this listener has served

swarm.undertow.servers.KEY.http-listeners.KEY.request-parse-timeout

The maximum amount of time (in milliseconds) that can be spent parsing the request

swarm.undertow.servers.KEY.http-listeners.KEY.resolve-peer-address

Enables host dns lookup

swarm.undertow.servers.KEY.http-listeners.KEY.secure

If this is true then requests that originate from this listener are marked as secure, even if the request is not using HTTPS.

swarm.undertow.servers.KEY.http-listeners.KEY.send-buffer

The send buffer size, in bytes.

swarm.undertow.servers.KEY.http-listeners.KEY.socket-binding

The listener socket binding

swarm.undertow.servers.KEY.http-listeners.KEY.tcp-backlog

Configure a server with the specified backlog.

swarm.undertow.servers.KEY.http-listeners.KEY.tcp-keep-alive

Configure a channel to send TCP keep-alive messages in an implementation-dependent manner.

swarm.undertow.servers.KEY.http-listeners.KEY.url-charset

URL charset

swarm.undertow.servers.KEY.http-listeners.KEY.worker

The listeners XNIO worker

swarm.undertow.servers.KEY.http-listeners.KEY.write-timeout

Configure a write timeout for a socket, in milliseconds. If the given amount of time elapses without a successful write taking place, the socket’s next write will throw a {@link WriteTimeoutException}.

swarm.undertow.servers.KEY.https-listeners.KEY.allow-encoded-slash

If a request comes in with encoded / characters (i.e. %2F), will these be decoded.

swarm.undertow.servers.KEY.https-listeners.KEY.allow-equals-in-cookie-value

If this is true then Undertow will allow non-escaped equals characters in unquoted cookie values. Unquoted cookie values may not contain equals characters. If present the value ends before the equals sign. The remainder of the cookie value will be dropped.

swarm.undertow.servers.KEY.https-listeners.KEY.always-set-keep-alive

If this is true then a Connection: keep-alive header will be added to responses, even when it is not strictly required by the specification.

swarm.undertow.servers.KEY.https-listeners.KEY.buffer-pipelined-data

If we should buffer pipelined requests.

swarm.undertow.servers.KEY.https-listeners.KEY.buffer-pool

The listeners buffer pool

swarm.undertow.servers.KEY.https-listeners.KEY.bytes-received

The number of bytes that have been received by this listener

swarm.undertow.servers.KEY.https-listeners.KEY.bytes-sent

The number of bytes that have been sent out on this listener

swarm.undertow.servers.KEY.https-listeners.KEY.decode-url

If this is true then the parser will decode the URL and query parameters using the selected character encoding (UTF-8 by default). If this is false they will not be decoded. This will allow a later handler to decode them into whatever charset is desired.

swarm.undertow.servers.KEY.https-listeners.KEY.disallowed-methods

A comma separated list of HTTP methods that are not allowed

swarm.undertow.servers.KEY.https-listeners.KEY.enable-http2

Enables HTTP2 support for this listener

swarm.undertow.servers.KEY.https-listeners.KEY.enabled

If the listener is enabled

swarm.undertow.servers.KEY.https-listeners.KEY.enabled-cipher-suites

Configures Enabled SSL cyphers

swarm.undertow.servers.KEY.https-listeners.KEY.enabled-protocols

Configures SSL protocols

swarm.undertow.servers.KEY.https-listeners.KEY.error-count

The number of 500 responses that have been sent by this listener

swarm.undertow.servers.KEY.https-listeners.KEY.http2-enable-push

If server push is enabled for this connection

swarm.undertow.servers.KEY.https-listeners.KEY.http2-header-table-size

The size of the header table used for HPACK compression, in bytes. This amount of memory will be allocated per connection for compression. Larger values use more memory but may give better compression.

swarm.undertow.servers.KEY.https-listeners.KEY.http2-initial-window-size

The flow control window size that controls how quickly the client can send data to the server

swarm.undertow.servers.KEY.https-listeners.KEY.http2-max-concurrent-streams

The maximum number of HTTP/2 streams that can be active at any time on a single connection

swarm.undertow.servers.KEY.https-listeners.KEY.http2-max-frame-size

The max HTTP/2 frame size

swarm.undertow.servers.KEY.https-listeners.KEY.http2-max-header-list-size

The maximum size of request headers the server is prepared to accept

swarm.undertow.servers.KEY.https-listeners.KEY.max-buffered-request-size

Maximum size of a buffered request, in bytes. Requests are not usually buffered, the most common case is when performing SSL renegotiation for a POST request, and the post data must be fully buffered in order to perform the renegotiation.

swarm.undertow.servers.KEY.https-listeners.KEY.max-connections

The maximum number of concurrent connections. Only values greater than 0 are allowed. For unlimited connections simply undefine this attribute value.

swarm.undertow.servers.KEY.https-listeners.KEY.max-cookies

The maximum number of cookies that will be parsed. This is used to protect against hash vulnerabilities.

swarm.undertow.servers.KEY.https-listeners.KEY.max-header-size

The maximum size of a http request header, in bytes.

swarm.undertow.servers.KEY.https-listeners.KEY.max-headers

The maximum number of headers that will be parsed. This is used to protect against hash vulnerabilities.

swarm.undertow.servers.KEY.https-listeners.KEY.max-parameters

The maximum number of parameters that will be parsed. This is used to protect against hash vulnerabilities. This applies to both query parameters, and to POST data, but is not cumulative (i.e. you can potentially have max parameters * 2 total parameters).

swarm.undertow.servers.KEY.https-listeners.KEY.max-post-size

The maximum size of a post that will be accepted, in bytes.

swarm.undertow.servers.KEY.https-listeners.KEY.max-processing-time

The maximum processing time taken by a request on this listener

swarm.undertow.servers.KEY.https-listeners.KEY.no-request-timeout

The length of time in milliseconds that the connection can be idle before it is closed by the container, defaults to 60000 (one minute)

swarm.undertow.servers.KEY.https-listeners.KEY.processing-time

The total processing time of all requests handed by this listener

swarm.undertow.servers.KEY.https-listeners.KEY.read-timeout

Configure a read timeout for a socket, in milliseconds. If the given amount of time elapses without a successful read taking place, the socket’s next read will throw a {@link ReadTimeoutException}.

swarm.undertow.servers.KEY.https-listeners.KEY.receive-buffer

The receive buffer size, in bytes.

swarm.undertow.servers.KEY.https-listeners.KEY.record-request-start-time

If this is true then Undertow will record the request start time, to allow for request time to be logged. This has a small but measurable performance impact

swarm.undertow.servers.KEY.https-listeners.KEY.request-count

The number of requests this listener has served

swarm.undertow.servers.KEY.https-listeners.KEY.request-parse-timeout

The maximum amount of time (in milliseconds) that can be spent parsing the request

swarm.undertow.servers.KEY.https-listeners.KEY.resolve-peer-address

Enables host dns lookup

swarm.undertow.servers.KEY.https-listeners.KEY.secure

If this is true then requests that originate from this listener are marked as secure, even if the request is not using HTTPS.

swarm.undertow.servers.KEY.https-listeners.KEY.security-realm

The listeners security realm

swarm.undertow.servers.KEY.https-listeners.KEY.send-buffer

The send buffer size, in bytes.

swarm.undertow.servers.KEY.https-listeners.KEY.socket-binding

The listener socket binding

swarm.undertow.servers.KEY.https-listeners.KEY.ssl-session-cache-size

The maximum number of active SSL sessions

swarm.undertow.servers.KEY.https-listeners.KEY.ssl-session-timeout

The timeout for SSL sessions, in seconds

swarm.undertow.servers.KEY.https-listeners.KEY.tcp-backlog

Configure a server with the specified backlog.

swarm.undertow.servers.KEY.https-listeners.KEY.tcp-keep-alive

Configure a channel to send TCP keep-alive messages in an implementation-dependent manner.

swarm.undertow.servers.KEY.https-listeners.KEY.url-charset

URL charset

swarm.undertow.servers.KEY.https-listeners.KEY.verify-client

The desired SSL client authentication mode for SSL channels

swarm.undertow.servers.KEY.https-listeners.KEY.worker

The listeners XNIO worker

swarm.undertow.servers.KEY.https-listeners.KEY.write-timeout

Configure a write timeout for a socket, in milliseconds. If the given amount of time elapses without a successful write taking place, the socket’s next write will throw a {@link WriteTimeoutException}.

swarm.undertow.servers.KEY.servlet-container

The servers default servlet container

swarm.undertow.servlet-containers.KEY.allow-non-standard-wrappers

If true then request and response wrappers that do not extend the standard wrapper classes can be used

swarm.undertow.servlet-containers.KEY.crawler-session-management-setting.session-timeout

The session timeout for sessions that are owned by crawlers

swarm.undertow.servlet-containers.KEY.crawler-session-management-setting.user-agents

Regular expression that is used to match the user agenet of a crawler

swarm.undertow.servlet-containers.KEY.default-buffer-cache

The buffer cache to use for caching static resources

swarm.undertow.servlet-containers.KEY.default-encoding

Default encoding to use for all deployed applications

swarm.undertow.servlet-containers.KEY.default-session-timeout

The default session timeout (in minutes) for all applications deployed in the container.

swarm.undertow.servlet-containers.KEY.directory-listing

If directory listing should be enabled for default servlets.

swarm.undertow.servlet-containers.KEY.disable-caching-for-secured-pages

If Undertow should set headers to disable caching for secured paged. Disabling this can cause security problems, as sensitive pages may be cached by an intermediary.

swarm.undertow.servlet-containers.KEY.eager-filter-initialization

If true undertow calls filter init() on deployment start rather than when first requested.

swarm.undertow.servlet-containers.KEY.ignore-flush

Ignore flushes on the servlet output stream. In most cases these just hurt performance for no good reason.

swarm.undertow.servlet-containers.KEY.jsp-setting.check-interval

Check interval for JSP updates using a background thread.

swarm.undertow.servlet-containers.KEY.jsp-setting.development

Enable Development mode which enables reloading JSP on-the-fly

swarm.undertow.servlet-containers.KEY.jsp-setting.disabled

Enable the JSP container.

swarm.undertow.servlet-containers.KEY.jsp-setting.display-source-fragment

When a runtime error occurs, attempts to display corresponding JSP source fragment

swarm.undertow.servlet-containers.KEY.jsp-setting.dump-smap

Write SMAP data to a file.

swarm.undertow.servlet-containers.KEY.jsp-setting.error-on-use-bean-invalid-class-attribute

Enable errors when using a bad class in useBean.

swarm.undertow.servlet-containers.KEY.jsp-setting.generate-strings-as-char-arrays

Generate String constants as char arrays.

swarm.undertow.servlet-containers.KEY.jsp-setting.java-encoding

Specify the encoding used for Java sources.

swarm.undertow.servlet-containers.KEY.jsp-setting.keep-generated

Keep the generated Servlets.

swarm.undertow.servlet-containers.KEY.jsp-setting.mapped-file

Map to the JSP source.

swarm.undertow.servlet-containers.KEY.jsp-setting.modification-test-interval

Minimum amount of time between two tests for updates, in seconds.

swarm.undertow.servlet-containers.KEY.jsp-setting.optimize-scriptlets

If JSP scriptlets should be optimised to remove string concatenation

swarm.undertow.servlet-containers.KEY.jsp-setting.recompile-on-fail

Retry failed JSP compilations on each request.

swarm.undertow.servlet-containers.KEY.jsp-setting.scratch-dir

Specify a different work directory.

swarm.undertow.servlet-containers.KEY.jsp-setting.smap

Enable SMAP.

swarm.undertow.servlet-containers.KEY.jsp-setting.source-vm

Source VM level for compilation.

swarm.undertow.servlet-containers.KEY.jsp-setting.tag-pooling

Enable tag pooling.

swarm.undertow.servlet-containers.KEY.jsp-setting.target-vm

Target VM level for compilation.

swarm.undertow.servlet-containers.KEY.jsp-setting.trim-spaces

Trim some spaces from the generated Servlet.

swarm.undertow.servlet-containers.KEY.jsp-setting.x-powered-by

Enable advertising the JSP engine in x-powered-by.

swarm.undertow.servlet-containers.KEY.max-sessions

The maximum number of sessions that can be active at one time

swarm.undertow.servlet-containers.KEY.mime-mappings.KEY.value

The mime type for this mapping

swarm.undertow.servlet-containers.KEY.persistent-sessions-setting.path

The path to the persistent session data directory. If this is null sessions will be stored in memory

swarm.undertow.servlet-containers.KEY.persistent-sessions-setting.relative-to

The directory the path is relative to

swarm.undertow.servlet-containers.KEY.proactive-authentication

If proactive authentication should be used. If this is true a user will always be authenticated if credentials are present.

swarm.undertow.servlet-containers.KEY.session-cookie-setting.comment

Cookie comment

swarm.undertow.servlet-containers.KEY.session-cookie-setting.domain

Cookie domain

swarm.undertow.servlet-containers.KEY.session-cookie-setting.http-only

Is cookie http-only

swarm.undertow.servlet-containers.KEY.session-cookie-setting.max-age

Max age of cookie

swarm.undertow.servlet-containers.KEY.session-cookie-setting.name

Name of the cookie

swarm.undertow.servlet-containers.KEY.session-cookie-setting.secure

Is cookie secure?

swarm.undertow.servlet-containers.KEY.session-id-length

The length of the generated session ID. Longer session ID’s are more secure.

swarm.undertow.servlet-containers.KEY.stack-trace-on-error

If an error page with the stack trace should be generated on error. Values are all, none and local-only

swarm.undertow.servlet-containers.KEY.use-listener-encoding

Use encoding defined on listener

swarm.undertow.servlet-containers.KEY.websockets-setting.buffer-pool

The buffer pool to use for websocket deployments

swarm.undertow.servlet-containers.KEY.websockets-setting.dispatch-to-worker

If callbacks should be dispatched to a worker thread. If this is false then they will be run in the IO thread, which is faster however care must be taken not to perform blocking operations.

swarm.undertow.servlet-containers.KEY.websockets-setting.worker

The worker to use for websocket deployments

swarm.undertow.statistics-enabled

Configures if statistics are enabled

6.64. Vert.x

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>vertx</artifactId>
</dependency>
Configuration
swarm.vertx.cluster.host

Vertx cluster host name

swarm.vertx.cluster.port

Vertx cluster port

swarm.vertx.inhibit-adapter-deployment

Flag to inhibit resource-adapter deployment

swarm.vertx.jndi-name

JNDI name of the Vertx connector

6.65. Web

Provides a collection of fractions equivalent to the Web Profile:

  • Bean Validation

  • CDI

  • EJB

  • JAX-RS

    • JSON-P

    • JAXB

    • Multipart

    • Validator

  • JPA

  • JSF

  • Transactions

  • Undertow (Servlets)

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>web</artifactId>
</dependency>

6.66. Web Services

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>webservices</artifactId>
</dependency>
Configuration
swarm.web-services.client-configs.KEY.post-handler-chains.KEY.handlers.KEY.attribute-class

Handler class

swarm.web-services.client-configs.KEY.post-handler-chains.KEY.protocol-bindings

Protocol binding

swarm.web-services.client-configs.KEY.pre-handler-chains.KEY.handlers.KEY.attribute-class

Handler class

swarm.web-services.client-configs.KEY.pre-handler-chains.KEY.protocol-bindings

Protocol binding

swarm.web-services.client-configs.KEY.properties.KEY.value

Endpoint configuration property value

swarm.web-services.endpoint-configs.KEY.post-handler-chains.KEY.handlers.KEY.attribute-class

Handler class

swarm.web-services.endpoint-configs.KEY.post-handler-chains.KEY.protocol-bindings

Protocol binding

swarm.web-services.endpoint-configs.KEY.pre-handler-chains.KEY.handlers.KEY.attribute-class

Handler class

swarm.web-services.endpoint-configs.KEY.pre-handler-chains.KEY.protocol-bindings

Protocol binding

swarm.web-services.endpoint-configs.KEY.properties.KEY.value

Endpoint configuration property value

swarm.web-services.modify-wsdl-address

Whether the soap address can be modified.

swarm.web-services.statistics-enabled

Whether statistics are to be gathered for endpoints, default value is 'false'.

swarm.web-services.wsdl-host

The WSDL, that is a required deployment artifact for an endpoint, has a <soap:address> element which points to the location of the endpoint. JBoss supports rewriting of that SOAP address. If the content of <soap:address> is a valid URL, JBossWS will not rewrite it unless 'modify-wsdl-address' is true. If the content of <soap:address> is not a valid URL, JBossWS will rewrite it using the attribute values given below. If 'wsdl-host' is set to 'jbossws.undefined.host', JBossWS uses requesters host when rewriting the <soap:address>

swarm.web-services.wsdl-path-rewrite-rule

This string defines a SED substitution command (e.g., 's/regexp/replacement/g') that JBossWS executes against the path component of each <soap:address> URL published from the server. When wsdl-path-rewrite-rule is not defined, JBossWS retains the original path component of each <soap:address> URL. When 'modify-wsdl-address' is set to "false" this element is ignored.

swarm.web-services.wsdl-port

The non-secure port that will be used for rewriting the SOAP address. If absent the port will be identified by querying the list of installed connectors.

swarm.web-services.wsdl-secure-port

The secure port that will be used for rewriting the SOAP address. If absent the port will be identified by querying the list of installed connectors.

swarm.web-services.wsdl-uri-scheme

The URI scheme to use for rewriting <soap:address> . Valid values are 'http' and 'https'. This configuration overrides scheme computed by processing the endpoint (even if a transport guarantee is specified). The provided values for 'wsdl-port' and 'wsdl-secure-port' (or their default values) are used depending on specified scheme.

6.67. Zipkin - JAXRS Support

Maven Coordinates
<dependency>
  <groupId>org.wildfly.swarm</groupId>
  <artifactId>zipkin-jaxrs</artifactId>
</dependency>
Configuration
swarm.zipkin.name

The service name used in reports

swarm.zipkin.rate

The reporting rate

swarm.zipkin.url

URL of the Zipkin server