Infinispan

STABLE

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)

results matching ""

    No results matching ""