Defines the configuration for Infinispan, for the cache manager configuration, for the default cache, and for named caches.
jgroups?
Defines JGroups stacks.
Defines JGroups transport stacks.Name | Type | Default | Description |
---|---|---|---|
transport | string | org.infinispan.remoting.transport.jgroups.JGroupsTransport | Class that represents a network transport. Must implement org.infinispan.remoting.transport.Transport. |
stack-file*
Name | Type | Default | Description |
---|---|---|---|
name | string | Name of the stack, to be referenced by transport's stack attribute. | |
path | string | Path of JGroups configuration file containing stack definition. |
stack*
Name | Type | Default | Description |
---|---|---|---|
name | string | Name of the stack, to be referenced by transport's stack attribute. | |
extends | string | The base stack to extend. |
remote-sites?
Defines the relay configuration.
Name | Type | Default | Description |
---|---|---|---|
default-stack | string | Defines the name of the JGroups stack to be used by default when connecting to remote sites. | |
cluster | string | xsite | Defines the default cluster name for remote clusters. |
remote-site
Name | Type | Default | Description |
---|---|---|---|
name | string | Defines the name of the remote site. | |
stack | string | Defines the name of the JGroups stack to use to connect to the remote site. If unspecified, the default-stack will be used. | |
cluster | string | Defines the name for the underlying group communication cluster. If unspecified, the remote-sites.cluster name will be used. |
ASYM_ENCRYPT
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
asym_algorithm | string | Cipher engine transformation for asymmetric algorithm. Default is RSA | |
asym_keylength | string | Initial public/private key length. Default is 2048 | |
change_key_on_coord_leave | string | Change the secret group key when the coordinator changes. If enabled, this will take place even if change_key_on_leave is disabled. | |
change_key_on_leave | string | When a node leaves, change the secret group key, preventing old members from eavesdropping | |
cipher_pool_size | string | Number of ciphers in the pool to parallelize encrypt and decrypt requests | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
key_map_max_size | string | Max number of keys in key_map | |
level | string | logger level (see javadocs) | |
policies | string | ||
provider | string | Cryptographic Service Provider | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
sym_algorithm | string | Cipher engine transformation for symmetric algorithm. Default is AES | |
sym_iv_length | string | Initialization vector length for symmetric encryption. A value must be specified here if the configured sym_algorithm requires an initialization vector. | |
sym_keylength | string | Initial key length for matching symmetric algorithm. Default is 128 | |
use_external_key_exchange | string | If true, a separate KeyExchange protocol (somewhere in the stack) is used to fetch the shared secret key. If false, the default (built-in) key exchange protocol will be used. |
AUTH
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
auth_class | string | The fully qualified name of the class implementing the AuthToken interface | |
auth_coord | string | Do join or merge responses from the coordinator also need to be authenticated | |
auth_value | string | ||
cert_alias | string | ||
cert_password | string | ||
cipher_type | string | ||
client_password | string | ||
client_principal_name | string | ||
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
fixed_members_seperator | string | ||
fixed_members_value | string | ||
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
keystore_password | string | ||
keystore_path | string | ||
keystore_type | string | ||
level | string | logger level (see javadocs) | |
match_ip_address | string | ||
match_logical_name | string | ||
match_string | string | ||
policies | string | ||
service_principal_name | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
BARRIER
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
flush_timeout | string | Max time (in ms) to wait until the threads which passed the barrier before it was closed have completed. If this time elapses, an exception will be thrown and state transfer will fail. 0= wait forever | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_close_time | string | Max time barrier can be closed. Default is 60000 ms | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
BATCH
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
flush_interval | string | Max interval (millis) at which the queued messages are sent | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_batch_size | string | The maximum number of messages per batch | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
BATCH2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
flush_interval | string | Max interval (millis) at which the queued messages are sent | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_batch_size | string | The maximum number of messages per batch | |
policies | string | ||
poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
BPING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
bind_port | string | Port for discovery packets | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
dest | string | Target address for broadcasts. This should be restricted to the local subnet, e.g. 192.168.1.255 | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
port_range | string | Sends discovery packets to ports 8555 to (8555+port_range) | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
CENTRAL_LOCK
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bypass_bundling | string | bypasses message bundling if set | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
lock_striping_size | string | Number of locks to be used for lock striping (for synchronized access to the server_lock entries) | |
num_backups | string | Number of backups to the coordinator. Server locks get replicated to these nodes as well | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_thread_id_for_lock_owner | string | By default, a lock owner is address:thread-id. If false, we only use the node's address. See https://issues.redhat.com/browse/JGRP-1886 for details |
CENTRAL_LOCK2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bypass_bundling | string | bypasses message bundling if set | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
lock_reconciliation_timeout | string | Max time (im ms) to wait for lock info responses from members in a lock reconciliation phase | |
lock_striping_size | string | Number of locks to be used for lock striping (for synchronized access to the server_lock entries) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_thread_id_for_lock_owner | string | By default, a lock owner is address:thread-id. If false, we only use the node's address. See https://issues.redhat.com/browse/JGRP-1886 for details |
CLEAR_FLAGS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
oob | string | clear OOB flags | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
COMPRESS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
compression_level | string | Compression level (from java.util.zip.Deflater) (0=no compression, 1=best speed, 9=best compression). Default is 9 | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
min_size | string | Minimal payload size of a message (in bytes) for compression to kick in. Default is 500 bytes | |
policies | string | ||
pool_size | string | Number of inflaters/deflaters for concurrent processing. Default is 2 | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
COUNTER
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bypass_bundling | string | Bypasses message bundling if true | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
num_backups | string | Number of backup coordinators. Modifications are asynchronously sent to all backup coordinators | |
policies | string | ||
reconciliation_timeout | string | Number of milliseconds to wait for reconciliation responses from all current members | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Request timeouts (in ms). If the timeout elapses, a TimeoutException will be thrown |
DAISYCHAIN
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
loopback | string | Loop back multicast messages | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
DELAY
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
constant_delay | string | Keep the delay constant. By default delay time randoms between 0 and upper bound | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
in_delay | string | Upper bound of number of milliseconds to delay passing a message up the stack (exclusive) | |
in_delay_nanos | string | Number of nanoseconds to delay passing a message up the stack | |
level | string | logger level (see javadocs) | |
out_delay | string | Upper bound number of milliseconds to delay passing a message down the stack (exclusive) | |
out_delay_nanos | string | Number of nanoseconds to delay passing a message down the stack | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
DETECT_LOOPBACKS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
print_to_stdout | string | Prints to stdout | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
DH_KEY_EXCHANGE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
secret_key_algorithm | string | The type of secret key to be sent up the stack (converted from DH). Should be the same as the algorithm part of ASYM_ENCRYPT.sym_algorithm if ASYM_ENCRYPT is used | |
secret_key_length | string | The length of the secret key (in bits) to be sent up the stack. AES requires 128 bits. Should be the same as ASYM_ENCRYPT.sym_keylength if ASYM_ENCRYPT is used. | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Max time (in ms) that a FETCH_SECRET_KEY down event will be ignored (if an existing request is in progress) until a new request for the secret key is sent to the keyserver |
DISCARD
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
discard_all | string | Drops all messages (up or down) if true | |
down | string | ||
drop_down_multicasts | string | Number of subsequent multicasts to drop in the down direction | |
drop_down_unicasts | string | Number of subsequent unicasts to drop in the down direction | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
excludeItself | string | If discard_all is true, still sends messages to self | |
gui | string | use a GUI or not | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
up | string |
DISCARD_PAYLOAD
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
duplicate | string | ||
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
seqno | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
DROP
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
DUPL
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
copy_multicast_msgs | string | Whether or not to copy multicast messages | |
copy_unicast_msgs | string | Whether or not to copy unicast messages | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
incoming_copies | string | Number of copies of each incoming message (0=no copies) | |
level | string | logger level (see javadocs) | |
outgoing_copies | string | Number of copies of each outgoing message (0=no copies) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
EXAMPLE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
FD_ALL
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
interval | string | Interval at which a HEARTBEAT is sent to the cluster | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Timeout after which a node is suspected if neither a heartbeat nor data have been received from it | |
timeout_check_interval | string | Interval at which the HEARTBEAT timeouts are checked | |
use_time_service | string | Uses TimeService to get the current time rather than calling System.nanoTime(). |
FD_ALL2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
interval | string | Interval at which a HEARTBEAT is sent to the cluster | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Timeout after which a node is suspected if neither a heartbeat nor data have been received from it |
FD_ALL3
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
interval | string | Interval at which a HEARTBEAT is sent to the cluster | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Timeout after which a node is suspected if neither a heartbeat nor data have been received from it |
FD_HOST
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
check_timeout | string | Max time (in ms) that a liveness check for a single host can take | |
cmd | string | The command used to check a given host for liveness. Example: "ping". If null, InetAddress.isReachable() will be used by default | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
interval | string | The interval (in ms) at which the hosts are checked for liveness | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Max time (in ms) after which a host is suspected if it failed all liveness checks | |
use_time_service | string | Uses TimeService to get the current time rather than System.currentTimeMillis. Might get removed soon, don't use ! |
FD_SOCK
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The NIC on which the ServerSocket should listen on. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
cache_max_age | string | Max age (in ms) an element marked as removed has to have until it is removed | |
cache_max_elements | string | Max number of elements in the cache until deleted elements are removed | |
client_bind_port | string | Start port for client socket. Default value of 0 picks a random port | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
get_cache_timeout | string | Timeout for getting socket cache from coordinator | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
keep_alive | string | Whether to use KEEP_ALIVE on the ping socket or not. Default is true | |
level | string | logger level (see javadocs) | |
num_tries | string | Number of attempts coordinator is solicited for socket cache until we give up | |
policies | string | ||
port_range | string | Number of ports to probe for start_port and client_bind_port | |
sock_conn_timeout | string | Max time in millis to wait for ping Socket.connect() to return | |
start_port | string | Start port for server socket. Default value of 0 picks a random port | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suspect_msg_interval | string | Interval for broadcasting suspect messages |
FD_SOCK2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The NIC on which the ServerSocket should listen on. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
client_bind_port | string | Start port for client socket. Default value of 0 picks a random port | |
connect_timeout | string | Max time (ms) to wait for a connect attempt | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks behind firewalls. On each firewall, set up a port forwarding rule to the local IP (e.g. 192.168.1.100) of the host, then on each host, set the "external_addr" TCP transport attribute to the external (public IP) address of the firewall | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
linger | string | SO_LINGER in seconds. Default of -1 disables it | |
max_port | string | The highest port the FD_SOCK server can listen on. Needed when wrapping around, looking for ports. See https://issues.redhat.com/browse/JGRP-2560 for details. | |
min_port | string | The lowest port the FD_SOCK server can listen on. Needed when wrapping around, looking for ports. See https://issues.redhat.com/browse/JGRP-2560 for details | |
offset | string | Offset from the transport's bind port | |
policies | string | ||
port_range | string | Number of ports to probe for finding a free port | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suspect_msg_interval | string | Interval for broadcasting suspect messages |
FILE_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
info_writer_max_writes_after_view | string | The max number of times my own information should be written to the storage after a view change | |
info_writer_sleep_time | string | Interval (in ms) at which the info writer should kick in | |
level | string | logger level (see javadocs) | |
location | string | The absolute path of the shared file | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
register_shutdown_hook | string | If set, a shutdown hook is registered with the JVM to remove the local address from the store. Default is true | |
remove_all_data_on_view_change | string | If true, on a view change, the new coordinator removes all data except its own | |
remove_old_coords_on_view_change | string | If true, on a view change, the new coordinator removes files from old coordinators | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
update_store_on_view_change | string | Change the backend store when the view changes. If off, then the file is only changed on joins, but not on leaves. Enabling this will increase traffic to the backend store. | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results | |
write_data_on_find | string | When a non-initial discovery is run, and InfoWriter is not running, write the data to disk (if true). JIRA: https://issues.redhat.com/browse/JGRP-2288 |
FORK
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
config | string | Points to an XML file defining the fork-stacks, which will be created at initialization. Ignored if null | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
process_state_events | string | If enabled, state transfer events will be processed, else they will be passed up | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
fork-stacks
FRAG
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
frag_size | string | The max number of bytes in a message. Larger messages will be fragmented | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
FRAG2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
frag_size | string | The max number of bytes in a message. Larger messages will be fragmented | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
FRAG3
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
frag_size | string | The max number of bytes in a message. Larger messages will be fragmented | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
FRAG4
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
frag_size | string | The max number of bytes in a message. Larger messages will be fragmented | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
Fragmentation
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
frag_size | string | The max number of bytes in a message. Larger messages will be fragmented | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
HDRS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
print_down | string | Enables printing of down messages | |
print_up | string | Enables printing of up (received) messages | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
INJECT_VIEW
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
JDBC_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
clear_sql | string | SQL to clear the table | |
connection_driver | string | The JDBC connection driver name | |
connection_password | string | The JDBC connection password | |
connection_url | string | The JDBC connection URL | |
connection_username | string | The JDBC connection username | |
contains_sql | string | Finds a given entry by its address and cluster name, used to implement a contains() | |
datasource_jndi_name | string | To use a DataSource registered in JNDI, specify the JNDI name here. This is an alternative to all connection_* configuration options: if this property is not empty, then all connection relatedproperties must be empty. | |
delete_single_sql | string | SQL used to delete a row. Customizable, but keep the order of parameters and pick compatible types: 1)Own Address, as String 2)Cluster name, as String | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
info_writer_max_writes_after_view | string | The max number of times my own information should be written to the storage after a view change | |
info_writer_sleep_time | string | Interval (in ms) at which the info writer should kick in | |
initialize_sql | string | If not empty, this SQL statement will be performed at startup.Customize it to create the needed table on those databases which permit table creation attempt without losing data, such as PostgreSQL and MySQL (using IF NOT EXISTS). To allow for creation attempts, errors performing this statement will be loggedbut not considered fatal. To avoid any DDL operation, set this to an empty string. | |
insert_single_sql | string | SQL used to insert a new row. Customizable, but keep the order of parameters and pick compatible types: 1)Own Address, as String 2)Cluster name, as String 3)Serialized PingData as byte[] | |
level | string | logger level (see javadocs) | |
location | string | The absolute path of the shared file | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
register_shutdown_hook | string | If set, a shutdown hook is registered with the JVM to remove the local address from the store. Default is true | |
remove_all_data_on_view_change | string | If true, on a view change, the new coordinator removes all data except its own | |
remove_old_coords_on_view_change | string | If true, on a view change, the new coordinator removes files from old coordinators | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
select_all_pingdata_sql | string | SQL used to fetch all node's PingData. Customizable, but keep the order of parameters and pick compatible types: only one parameter needed, String compatible, representing the Cluster name. Must return a byte[], the Serialized PingData as it was stored by the insert_single_sql statement. Must select primary keys subsequently for cleanup to work properly | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
update_store_on_view_change | string | Change the backend store when the view changes. If off, then the file is only changed on joins, but not on leaves. Enabling this will increase traffic to the backend store. | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results | |
write_data_on_find | string | When a non-initial discovery is run, and InfoWriter is not running, write the data to disk (if true). JIRA: https://issues.redhat.com/browse/JGRP-2288 |
LOCAL_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
MAKE_BATCH
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
multicasts | string | handle multicast messages | |
policies | string | ||
skip_oob | string | Do not add OOB messages to a batch if true | |
sleep_time | string | Time to sleep (in ms) from the reception of the first message to sending a batch up | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
unicasts | string | handle unicast messages |
MERGE3
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
check_interval | string | Interval (in ms) after which we check for view inconsistencies | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_interval | string | Interval (in milliseconds) when the next info message will be sent. A random value is picked from range [1..max_interval] | |
max_participants_in_merge | string | The max number of merge participants to be involved in a merge. 0 sets this to unlimited. | |
min_interval | string | Minimum time in ms before sending an info message | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
MFC
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_block_time | string | Max time (in ms) to block | |
max_credits | string | Max number of bytes to send per receiver until an ack must be received to proceed | |
min_credits | string | Computed as max_credits x min_theshold unless explicitly set | |
min_threshold | string | The threshold (as a percentage of max_credits) at which a receiver sends more credits to a sender. Example: if max_credits is 1'000'000, and min_threshold 0.25, then we send ca. 250'000 credits to P once we've got only 250'000 credits left for P (we've received 750'000 bytes from P) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
MFC_NB
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_block_time | string | Max time (in ms) to block | |
max_credits | string | Max number of bytes to send per receiver until an ack must be received to proceed | |
max_queue_size | string | Max number of bytes of all queued messages for a given destination. If a given destination has no credits left and the message cannot be added to the queue because it is full, then the sender thread will be blocked until there is again space available in the queue, or the protocol is stopped. | |
min_credits | string | Computed as max_credits x min_theshold unless explicitly set | |
min_threshold | string | The threshold (as a percentage of max_credits) at which a receiver sends more credits to a sender. Example: if max_credits is 1'000'000, and min_threshold 0.25, then we send ca. 250'000 credits to P once we've got only 250'000 credits left for P (we've received 750'000 bytes from P) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
MPING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
bind_addr | string | Bind address for multicast socket. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
bind_interface | string | The interface (NIC) which should be used by this transport | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
ip_ttl | string | Time to live for discovery packets. Default is 8 | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
mcast_addr | string | Multicast address to be used for discovery | |
mcast_port | string | Multicast port for discovery packets. Default is 7555 | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
receive_interfaces | string | List of interfaces to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
send_interfaces | string | List of interfaces to send multicasts on | |
send_on_all_interfaces | string | Whether send messages are sent on all interfaces. Default is false | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
PDC
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
cache_dir | string | The absolute path of the directory for the disk cache. The mappings will be stored as individual files in this directory | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
PERF
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
avg_size | string | Number of samples to maintain for rolling average | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
RACKSPACE_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
apiKey | string | Rackspace API access key | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
container | string | Name of the root container | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
info_writer_max_writes_after_view | string | The max number of times my own information should be written to the storage after a view change | |
info_writer_sleep_time | string | Interval (in ms) at which the info writer should kick in | |
level | string | logger level (see javadocs) | |
location | string | The absolute path of the shared file | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
region | string | Rackspace region, either UK or US | |
register_shutdown_hook | string | If set, a shutdown hook is registered with the JVM to remove the local address from the store. Default is true | |
remove_all_data_on_view_change | string | If true, on a view change, the new coordinator removes all data except its own | |
remove_old_coords_on_view_change | string | If true, on a view change, the new coordinator removes files from old coordinators | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
update_store_on_view_change | string | Change the backend store when the view changes. If off, then the file is only changed on joins, but not on leaves. Enabling this will increase traffic to the backend store. | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results | |
username | string | Rackspace username | |
write_data_on_find | string | When a non-initial discovery is run, and InfoWriter is not running, write the data to disk (if true). JIRA: https://issues.redhat.com/browse/JGRP-2288 |
RATE_LIMITER
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_bytes | string | Max number of bytes to be sent in time_period ms. Blocks the sender if exceeded until a new time period has started | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
time_period | string | Number of milliseconds during which max_bytes bytes can be sent |
RED
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
enabled | string | If false, all messages are passed down. Will be set to false if the bundler returns a queue size of -1 | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_threshold | string | The max threshold (percentage between min_threshold and 1.0) above which all messages are dropped | |
min_threshold | string | The min threshold (percentage between 0 and 1.0) below which no message is dropped | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
weight_factor | string | The weight used to compute the average queue size. The higher the value is, the less the current queue size is taken into account. E.g. with 2, 25% of the current queue size and 75% of the old average is taken to compute the new average. In other words: with a high value, the average will take longer to reflect the current queue size. |
REVERSE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
RSVP
Name | Type | Default | Description |
---|---|---|---|
ack_on_delivery | string | When true, we pass the message up to the application and only then send an ack. When false, we send an ack first and only then pass the message up to the application. | |
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
resend_interval | string | Interval (in milliseconds) at which we resend the RSVP request. Needs to be < timeout. 0 disables it. | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
throw_exception_on_timeout | string | Whether an exception should be thrown when the timeout kicks in, and we haven't yet received all acks. An exception would be thrown all the way up to JChannel.send(). If we use RSVP_NB, this will be ignored. | |
timeout | string | Max time in milliseconds to block for an RSVP'ed message (0 blocks forever). |
SEQUENCER
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
delivery_table_max_size | string | Size of the set to store received seqnos (for duplicate checking) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
flush_forward_table | string | If true, all messages in the forward-table are sent to the new coord, else thye're dropped (https://issues.redhat.com/browse/JGRP-2268) | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
threshold | string | Number of acks needed before going from ack-mode to normal mode. 0 disables this, which means that ack-mode is always on |
SEQUENCER2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
SERIALIZE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
SHARED_LOOPBACK
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by this transport. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address | |
bind_port | string | The port to which the transport binds. Default of 0 binds to any (ephemeral) port. See also port_range | |
bundler.capacity | string | The max number of elements in a bundler if the bundler supports size limitations | |
bundler.flush_interval | string | Max interval (millis) at which the queued messages are sent | |
bundler.max_batch_size | string | The maximum number of messages per batch | |
bundler.max_size | string | Maximum number of bytes for messages to be queued until they are sent | |
bundler.max_threads | string | Max number of threads in thread pool | |
bundler.num_spins | string | Number of spins before a real lock is acquired | |
bundler.poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
bundler.remove_queue_size | string | The capacity of the remove queue | |
bundler.wait_strategy | string | The wait strategy: spin, yield, park, spin-park, spin-yield | |
bundler_type | string | The type of bundler used ("ring-buffer", "transfer-queue" (default), "sender-sends" or "no-bundler") or the fully qualified classname of a Bundler implementation | |
diag.bind_addr | string | Bind address for diagnostic probing, to bind the TCP socket. Used when enable_tcp is true | |
diag.bind_interfaces | string | Comma delimited list of interfaces (IP addrs or interface names) that the multicast socket should bind to | |
diag.enable_tcp | string | Use a TCP socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enable_udp | string | Use a multicast socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enabled | string | Switch to enable diagnostic probing | |
diag.mcast_addr | string | Multicast address for diagnostic probing (UDP MulticastSocket). Used when enable_udp is true | |
diag.passcode | string | Authorization passcode for diagnostics. If specified every probe query will be authorized | |
diag.port | string | Port for diagnostic probing. Default is 7500 | |
diag.port_range | string | The number of ports to be probed for an available port (TCP) | |
diag.ttl | string | TTL of the diagnostics multicast socket | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
local_transport_class | string | The fully qualified name of a class implementing LocalTransport | |
log_discard_msgs | string | whether or not warnings about messages from different groups are logged | |
log_discard_msgs_version | string | whether or not warnings about messages from members with a different version are discarded | |
logical_addr_cache_expiration | string | Time (in ms) after which entries in the logical address cache marked as removable can be removed. 0 never removes any entries (not recommended) | |
logical_addr_cache_max_size | string | Max number of elements in the logical address cache before eviction starts | |
logical_addr_cache_reaper_interval | string | Interval (in ms) at which the reaper task scans logical_addr_cache and removes entries marked as removable. 0 disables reaping. | |
loopback_copy | string | Whether or not to make a copy of a message before looping it back up. Don't use this; might get removed without warning | |
loopback_separate_thread | string | Loop back the message on a separate thread or use the current thread. Don't use this; might get removed without warning | |
message_processing_policy | string | The fully qualified name of a class implementing MessageProcessingPolicy | |
msg_factory_class | string | The fully qualified name of a MessageFactory implementation | |
policies | string | ||
port_range | string | The range of valid ports: [bind_port .. bind_port+port_range ]. 0 only binds to bind_port and fails if taken | |
receive_interfaces | string | Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_different_cluster_warnings | string | Time during which identical warnings about messages from a member from a different cluster will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_different_version_warnings | string | Time during which identical warnings about messages from a member with a different version will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
thread_naming_pattern | string | Thread naming pattern for threads in this channel. Valid values are "pcl": "p": includes the thread name, e.g. "Incoming thread-1", "UDP ucast receiver", "c": includes the cluster name, e.g. "MyCluster", "l": includes the local address of the current member, e.g. "192.168.5.1:5678" | |
thread_pool.delta | string | Added to the view size when the pool is increased dynamically | |
thread_pool.enabled | string | Whether or not the thread pool is enabled. If false, tasks will be run on the caller's thread | |
thread_pool.increase_max_size_dynamically | string | Increases max_threads by the view size + delta if enabled (https://issues.redhat.com/browse/JGRP-2655) | |
thread_pool.keep_alive_time | string | Timeout (ms) to remove idle threads from the pool | |
thread_pool.max_threads | string | Maximum thread pool size for the thread pool | |
thread_pool.min_threads | string | Minimum thread pool size for the thread pool | |
thread_pool.rejection_policy | string | The rejection policy to be used in the thread pool (abort, discard, run, custom etc. See Util.parseRejectionPolicy() for details | |
thread_pool.thread_dump_path | string | Path to which the thread dump will be written. Ignored if null | |
thread_pool.thread_dumps_threshold | string | The number of times a thread pool needs to be full before a thread dump is logged | |
time_service_interval | string | Interval (in ms) at which the time service updates its timestamp. 0 disables the time service | |
use_virtual_threads | string | If true, create virtual threads, otherwise create native threads | |
who_has_cache_timeout | string | Timeout (in ms) to determine how long to wait until a request to fetch the physical address for a given logical address will be sent again. Subsequent requests for the same physical address will therefore be spaced at least who_has_cache_timeout ms apart |
SHARED_LOOPBACK_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
SHUFFLE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
down | string | Reorder down messages and message batches | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_size | string | max number of messages before we reorder queued messages and send them up | |
max_time | string | max time (in millis) before we pass the reordered messages up or down | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
up | string | Reorder up messages and message batches |
SIZE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
min_size | string | ||
policies | string | ||
print_msg | string | ||
raw_buffer | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
SNIFF
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
down | string | Print sent messages | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
up | string | Print received messages |
SOS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
cmd | string | The attributes to be fetched. In probe format ('jmx' or 'op' command) | |
config | string | The configuration file containing all protocols and attributes to be dumped | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
filename | string | File to which the periodic data is written | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
interval | string | Interval in ms at which the attributes are fetched and written to the file | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
SSL_KEY_EXCHANGE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | Bind address for the server or client socket. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
keystore_name | string | Location of the keystore | |
keystore_password | string | Password to access the keystore | |
keystore_type | string | The type of the keystore. Types are listed in http://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html | |
level | string | logger level (see javadocs) | |
policies | string | ||
port | string | The port at which the key server is listening. If the port is not available, the next port will be probed, up to port+port_range. Used by the key server (server) to create an SSLServerSocket and by clients to connect to the key server. | |
port_range | string | The port range to probe | |
reload_threshold | string | Minimum time (in ms) before reloading the keystore and truststore from disk. | |
require_client_authentication | string | If enabled, clients are authenticated as well (not just the server). Set to true to prevent rogue clients to fetch the secret group key (e.g. via man-in-the-middle attacks) | |
secret_key_algorithm | string | The type of secret key to be sent up the stack (converted from DH). Should be the same as the algorithm part of ASYM_ENCRYPT.sym_algorithm if ASYM_ENCRYPT is used | |
session_verifier_arg | string | The argument to the session verifier | |
session_verifier_class | string | The fully qualified name of a class implementing SessionVerifier | |
socket_timeout | string | Timeout (in ms) for a socket read. This applies for example to the initial SSL handshake, e.g. if the client connects to a non-JGroups service accidentally running on the same port | |
ssl_protocol | string | The SSL protocol to use. Defaults to TLS | |
ssl_provider | string | The SSL security provider. Defaults to null, which will use the default JDK provider. | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
truststore_name | string | Location of the truststore. Defaults to null, which will use the keystore as a truststore. | |
truststore_password | string | Password to access the truststore | |
truststore_type | string | The type of the truststore. Types are listed in http://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html |
STATS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
STOMP
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by the server socket. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
endpoint_addr | string | If set, then endpoint will be set to this address | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
exact_destination_match | string | If set to false, then a destination of /a/b match /a/b/c, a/b/d, a/b/c/d etc | |
forward_non_client_generated_msgs | string | Forward received messages which don't have a StompHeader to clients | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
port | string | Port on which the STOMP protocol listens for requests | |
send_info | string | If true, information such as a list of endpoints, or views, will be sent to all clients (via the INFO command). This allows for example intelligent clients to connect to a different server should a connection be closed. | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
SWIFT_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
auth_type | string | Authentication type | |
auth_url | string | Authentication url | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
container | string | Name of the root container | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
info_writer_max_writes_after_view | string | The max number of times my own information should be written to the storage after a view change | |
info_writer_sleep_time | string | Interval (in ms) at which the info writer should kick in | |
level | string | logger level (see javadocs) | |
location | string | The absolute path of the shared file | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
password | string | Password | |
policies | string | ||
register_shutdown_hook | string | If set, a shutdown hook is registered with the JVM to remove the local address from the store. Default is true | |
remove_all_data_on_view_change | string | If true, on a view change, the new coordinator removes all data except its own | |
remove_old_coords_on_view_change | string | If true, on a view change, the new coordinator removes files from old coordinators | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
tenant | string | Openstack Keystone tenant name | |
update_store_on_view_change | string | Change the backend store when the view changes. If off, then the file is only changed on joins, but not on leaves. Enabling this will increase traffic to the backend store. | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results | |
username | string | Username | |
write_data_on_find | string | When a non-initial discovery is run, and InfoWriter is not running, write the data to disk (if true). JIRA: https://issues.redhat.com/browse/JGRP-2288 |
SYM_ENCRYPT
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
alias | string | Alias used for recovering the key. Change the default | |
asym_algorithm | string | Cipher engine transformation for asymmetric algorithm. Default is RSA | |
asym_keylength | string | Initial public/private key length. Default is 2048 | |
cipher_pool_size | string | Number of ciphers in the pool to parallelize encrypt and decrypt requests | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
key_map_max_size | string | Max number of keys in key_map | |
key_password | string | Password for recovering the key. Change the default | |
keystore_name | string | File on classpath that contains keystore repository | |
keystore_type | string | The type of the keystore. Types are listed in http://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html | |
level | string | logger level (see javadocs) | |
policies | string | ||
provider | string | Cryptographic Service Provider | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
store_password | string | Password used to check the integrity/unlock the keystore. Change the default | |
sym_algorithm | string | Cipher engine transformation for symmetric algorithm. Default is AES | |
sym_iv_length | string | Initialization vector length for symmetric encryption. A value must be specified here if the configured sym_algorithm requires an initialization vector. | |
sym_keylength | string | Initial key length for matching symmetric algorithm. Default is 128 |
SimpleTCP
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by this transport. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address | |
bind_port | string | The port to which the transport binds. Default of 0 binds to any (ephemeral) port. See also port_range | |
buffered_input_stream_size | string | Size of the buffer of the BufferedInputStream in TcpConnection. A read always tries to read ahead as much data as possible into the buffer. 0: default size | |
buffered_output_stream_size | string | Size of the buffer of the BufferedOutputStream in TcpConnection. Smaller messages are buffered until this size is exceeded or flush() is called. Bigger messages are sent immediately. 0: default size | |
bundler.capacity | string | The max number of elements in a bundler if the bundler supports size limitations | |
bundler.flush_interval | string | Max interval (millis) at which the queued messages are sent | |
bundler.max_batch_size | string | The maximum number of messages per batch | |
bundler.max_size | string | Maximum number of bytes for messages to be queued until they are sent | |
bundler.max_threads | string | Max number of threads in thread pool | |
bundler.num_spins | string | Number of spins before a real lock is acquired | |
bundler.poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
bundler.remove_queue_size | string | The capacity of the remove queue | |
bundler.wait_strategy | string | The wait strategy: spin, yield, park, spin-park, spin-yield | |
bundler_type | string | The type of bundler used ("ring-buffer", "transfer-queue" (default), "sender-sends" or "no-bundler") or the fully qualified classname of a Bundler implementation | |
diag.bind_addr | string | Bind address for diagnostic probing, to bind the TCP socket. Used when enable_tcp is true | |
diag.bind_interfaces | string | Comma delimited list of interfaces (IP addrs or interface names) that the multicast socket should bind to | |
diag.enable_tcp | string | Use a TCP socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enable_udp | string | Use a multicast socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enabled | string | Switch to enable diagnostic probing | |
diag.mcast_addr | string | Multicast address for diagnostic probing (UDP MulticastSocket). Used when enable_udp is true | |
diag.passcode | string | Authorization passcode for diagnostics. If specified every probe query will be authorized | |
diag.port | string | Port for diagnostic probing. Default is 7500 | |
diag.port_range | string | The number of ports to be probed for an available port (TCP) | |
diag.ttl | string | TTL of the diagnostics multicast socket | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
local_transport_class | string | The fully qualified name of a class implementing LocalTransport | |
log_discard_msgs | string | whether or not warnings about messages from different groups are logged | |
log_discard_msgs_version | string | whether or not warnings about messages from members with a different version are discarded | |
logical_addr_cache_expiration | string | Time (in ms) after which entries in the logical address cache marked as removable can be removed. 0 never removes any entries (not recommended) | |
logical_addr_cache_max_size | string | Max number of elements in the logical address cache before eviction starts | |
logical_addr_cache_reaper_interval | string | Interval (in ms) at which the reaper task scans logical_addr_cache and removes entries marked as removable. 0 disables reaping. | |
loopback_copy | string | Whether or not to make a copy of a message before looping it back up. Don't use this; might get removed without warning | |
loopback_separate_thread | string | Loop back the message on a separate thread or use the current thread. Don't use this; might get removed without warning | |
message_processing_policy | string | The fully qualified name of a class implementing MessageProcessingPolicy | |
msg_factory_class | string | The fully qualified name of a MessageFactory implementation | |
policies | string | ||
port_range | string | The range of valid ports: [bind_port .. bind_port+port_range ]. 0 only binds to bind_port and fails if taken | |
receive_interfaces | string | Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
recv_buf_size | string | size in bytes of TCP receiver window | |
send_buf_size | string | size in bytes of TCP send window | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_different_cluster_warnings | string | Time during which identical warnings about messages from a member from a different cluster will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_different_version_warnings | string | Time during which identical warnings about messages from a member with a different version will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
thread_naming_pattern | string | Thread naming pattern for threads in this channel. Valid values are "pcl": "p": includes the thread name, e.g. "Incoming thread-1", "UDP ucast receiver", "c": includes the cluster name, e.g. "MyCluster", "l": includes the local address of the current member, e.g. "192.168.5.1:5678" | |
thread_pool.delta | string | Added to the view size when the pool is increased dynamically | |
thread_pool.enabled | string | Whether or not the thread pool is enabled. If false, tasks will be run on the caller's thread | |
thread_pool.increase_max_size_dynamically | string | Increases max_threads by the view size + delta if enabled (https://issues.redhat.com/browse/JGRP-2655) | |
thread_pool.keep_alive_time | string | Timeout (ms) to remove idle threads from the pool | |
thread_pool.max_threads | string | Maximum thread pool size for the thread pool | |
thread_pool.min_threads | string | Minimum thread pool size for the thread pool | |
thread_pool.rejection_policy | string | The rejection policy to be used in the thread pool (abort, discard, run, custom etc. See Util.parseRejectionPolicy() for details | |
thread_pool.thread_dump_path | string | Path to which the thread dump will be written. Ignored if null | |
thread_pool.thread_dumps_threshold | string | The number of times a thread pool needs to be full before a thread dump is logged | |
time_service_interval | string | Interval (in ms) at which the time service updates its timestamp. 0 disables the time service | |
use_virtual_threads | string | If true, create virtual threads, otherwise create native threads | |
who_has_cache_timeout | string | Timeout (in ms) to determine how long to wait until a request to fetch the physical address for a given logical address will be sent again. Subsequent requests for the same physical address will therefore be spaced at least who_has_cache_timeout ms apart |
TCP
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by this transport. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address | |
bind_port | string | The port to which the transport binds. Default of 0 binds to any (ephemeral) port. See also port_range | |
buffered_input_stream_size | string | Size of the buffer of the BufferedInputStream in TcpConnection. A read always tries to read ahead as much data as possible into the buffer. 0: default size | |
buffered_output_stream_size | string | Size of the buffer of the BufferedOutputStream in TcpConnection. Smaller messages are buffered until this size is exceeded or flush() is called. Bigger messages are sent immediately. 0: default size | |
bundler.capacity | string | The max number of elements in a bundler if the bundler supports size limitations | |
bundler.flush_interval | string | Max interval (millis) at which the queued messages are sent | |
bundler.max_batch_size | string | The maximum number of messages per batch | |
bundler.max_size | string | Maximum number of bytes for messages to be queued until they are sent | |
bundler.max_threads | string | Max number of threads in thread pool | |
bundler.num_spins | string | Number of spins before a real lock is acquired | |
bundler.poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
bundler.remove_queue_size | string | The capacity of the remove queue | |
bundler.wait_strategy | string | The wait strategy: spin, yield, park, spin-park, spin-yield | |
bundler_type | string | The type of bundler used ("ring-buffer", "transfer-queue" (default), "sender-sends" or "no-bundler") or the fully qualified classname of a Bundler implementation | |
client_bind_addr | string | The address of a local network interface which should be used by client sockets to bind to. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
client_bind_port | string | The local port a client socket should bind to. If 0, an ephemeral port will be picked. | |
conn_expire_time | string | Max time connection can be idle before being reaped (in ms) | |
defer_client_bind_addr | string | If true, client sockets will not explicitly bind to bind_addr but will defer to the native socket | |
diag.bind_addr | string | Bind address for diagnostic probing, to bind the TCP socket. Used when enable_tcp is true | |
diag.bind_interfaces | string | Comma delimited list of interfaces (IP addrs or interface names) that the multicast socket should bind to | |
diag.enable_tcp | string | Use a TCP socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enable_udp | string | Use a multicast socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enabled | string | Switch to enable diagnostic probing | |
diag.mcast_addr | string | Multicast address for diagnostic probing (UDP MulticastSocket). Used when enable_udp is true | |
diag.passcode | string | Authorization passcode for diagnostics. If specified every probe query will be authorized | |
diag.port | string | Port for diagnostic probing. Default is 7500 | |
diag.port_range | string | The number of ports to be probed for an available port (TCP) | |
diag.ttl | string | TTL of the diagnostics multicast socket | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
linger | string | SO_LINGER in seconds. Default of -1 disables it | |
local_transport_class | string | The fully qualified name of a class implementing LocalTransport | |
log_accept_error | string | Log a warning (or not) when ServerSocket.accept() throws an exception | |
log_details | string | Log a stack trace when a connection is closed | |
log_discard_msgs | string | whether or not warnings about messages from different groups are logged | |
log_discard_msgs_version | string | whether or not warnings about messages from members with a different version are discarded | |
logical_addr_cache_expiration | string | Time (in ms) after which entries in the logical address cache marked as removable can be removed. 0 never removes any entries (not recommended) | |
logical_addr_cache_max_size | string | Max number of elements in the logical address cache before eviction starts | |
logical_addr_cache_reaper_interval | string | Interval (in ms) at which the reaper task scans logical_addr_cache and removes entries marked as removable. 0 disables reaping. | |
loopback_copy | string | Whether or not to make a copy of a message before looping it back up. Don't use this; might get removed without warning | |
loopback_separate_thread | string | Loop back the message on a separate thread or use the current thread. Don't use this; might get removed without warning | |
max_length | string | The max number of bytes a message can have. If greater, an exception will be thrown. 0 disables this | |
message_processing_policy | string | The fully qualified name of a class implementing MessageProcessingPolicy | |
msg_factory_class | string | The fully qualified name of a MessageFactory implementation | |
peer_addr_read_timeout | string | Max time to block on reading of peer address | |
policies | string | ||
port_range | string | The range of valid ports: [bind_port .. bind_port+port_range ]. 0 only binds to bind_port and fails if taken | |
reaper_interval | string | Reaper interval in msec. Default is 0 (no reaping) | |
receive_interfaces | string | Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
recv_buf_size | string | Receiver buffer size in bytes | |
send_buf_size | string | Send buffer size in bytes | |
sock_conn_timeout | string | Max time allowed for a socket creation in connection table | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_different_cluster_warnings | string | Time during which identical warnings about messages from a member from a different cluster will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_different_version_warnings | string | Time during which identical warnings about messages from a member with a different version will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
tcp_nodelay | string | Should TCP no delay flag be turned on | |
thread_naming_pattern | string | Thread naming pattern for threads in this channel. Valid values are "pcl": "p": includes the thread name, e.g. "Incoming thread-1", "UDP ucast receiver", "c": includes the cluster name, e.g. "MyCluster", "l": includes the local address of the current member, e.g. "192.168.5.1:5678" | |
thread_pool.delta | string | Added to the view size when the pool is increased dynamically | |
thread_pool.enabled | string | Whether or not the thread pool is enabled. If false, tasks will be run on the caller's thread | |
thread_pool.increase_max_size_dynamically | string | Increases max_threads by the view size + delta if enabled (https://issues.redhat.com/browse/JGRP-2655) | |
thread_pool.keep_alive_time | string | Timeout (ms) to remove idle threads from the pool | |
thread_pool.max_threads | string | Maximum thread pool size for the thread pool | |
thread_pool.min_threads | string | Minimum thread pool size for the thread pool | |
thread_pool.rejection_policy | string | The rejection policy to be used in the thread pool (abort, discard, run, custom etc. See Util.parseRejectionPolicy() for details | |
thread_pool.thread_dump_path | string | Path to which the thread dump will be written. Ignored if null | |
thread_pool.thread_dumps_threshold | string | The number of times a thread pool needs to be full before a thread dump is logged | |
time_service_interval | string | Interval (in ms) at which the time service updates its timestamp. 0 disables the time service | |
tls.cipher_suites | string | The list of cipher suites | |
tls.client_auth | string | Defines whether client certificate authentication is required. Legal values are NONE, WANT or NEED | |
tls.enabled | string | Enables TLS; when true, SSL sockets will be used instead of regular sockets | |
tls.keystore_alias | string | Alias used for fetching the key | |
tls.keystore_password | string | Keystore password | |
tls.keystore_path | string | Fully qualified path to the keystore | |
tls.keystore_type | string | The type of the keystore | |
tls.protocols | string | One or more TLS protocol names to use, e.g. TLSv1.2. Setting this requires configuring key and trust stores | |
tls.provider | string | The security provider. Defaults to null, which will use the default JDK provider | |
tls.sni_matchers | string | A list of regular expression that servers use to match and accept SNI host names | |
tls.truststore_password | string | The password of the truststore | |
tls.truststore_path | string | Fully qualified path to the truststore | |
tls.truststore_type | string | The type of the truststore | |
use_acks | string | Wait for an ack from the server when a connection is established (https://issues.redhat.com/browse/JGRP-2684) | |
use_virtual_threads | string | If true, create virtual threads, otherwise create native threads | |
who_has_cache_timeout | string | Timeout (in ms) to determine how long to wait until a request to fetch the physical address for a given logical address will be sent again. Subsequent requests for the same physical address will therefore be spaced at least who_has_cache_timeout ms apart |
TCPGOSSIP
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
initial_hosts | string | Comma delimited list of hosts to be contacted for initial membership | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
reconnect_interval | string | Interval (ms) by which a disconnected stub attempts to reconnect to the GossipRouter | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
sock_conn_timeout | string | Max time for socket creation. Default is 1000 ms | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results | |
use_nio | string | Whether to use blocking (false) or non-blocking (true) connections. If GossipRouter is used, this needs to be false; if GossipRouterNio is used, it needs to be true |
TCPPING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
initial_hosts | string | Comma delimited list of hosts to be contacted for initial membership. Ideally, all members should be listed. If this is not possible, send_cache_on_join and / or return_entire_cache can be set to true | |
level | string | logger level (see javadocs) | |
max_dynamic_hosts | string | max number of hosts to keep beyond the ones in initial_hosts | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
port_range | string | Number of additional ports to be probed for membership. A port_range of 0 does not probe additional ports. Example: initial_hosts=A[7800] port_range=0 probes A:7800, port_range=1 probes A:7800 and A:7801 | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
TCP_NIO2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by this transport. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address | |
bind_port | string | The port to which the transport binds. Default of 0 binds to any (ephemeral) port. See also port_range | |
bundler.capacity | string | The max number of elements in a bundler if the bundler supports size limitations | |
bundler.flush_interval | string | Max interval (millis) at which the queued messages are sent | |
bundler.max_batch_size | string | The maximum number of messages per batch | |
bundler.max_size | string | Maximum number of bytes for messages to be queued until they are sent | |
bundler.max_threads | string | Max number of threads in thread pool | |
bundler.num_spins | string | Number of spins before a real lock is acquired | |
bundler.poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
bundler.remove_queue_size | string | The capacity of the remove queue | |
bundler.wait_strategy | string | The wait strategy: spin, yield, park, spin-park, spin-yield | |
bundler_type | string | The type of bundler used ("ring-buffer", "transfer-queue" (default), "sender-sends" or "no-bundler") or the fully qualified classname of a Bundler implementation | |
client_bind_addr | string | The address of a local network interface which should be used by client sockets to bind to. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
client_bind_port | string | The local port a client socket should bind to. If 0, an ephemeral port will be picked. | |
conn_expire_time | string | Max time connection can be idle before being reaped (in ms) | |
copy_on_partial_write | string | If true, a partial write will make a copy of the data so a buffer can be reused | |
defer_client_bind_addr | string | If true, client sockets will not explicitly bind to bind_addr but will defer to the native socket | |
diag.bind_addr | string | Bind address for diagnostic probing, to bind the TCP socket. Used when enable_tcp is true | |
diag.bind_interfaces | string | Comma delimited list of interfaces (IP addrs or interface names) that the multicast socket should bind to | |
diag.enable_tcp | string | Use a TCP socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enable_udp | string | Use a multicast socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enabled | string | Switch to enable diagnostic probing | |
diag.mcast_addr | string | Multicast address for diagnostic probing (UDP MulticastSocket). Used when enable_udp is true | |
diag.passcode | string | Authorization passcode for diagnostics. If specified every probe query will be authorized | |
diag.port | string | Port for diagnostic probing. Default is 7500 | |
diag.port_range | string | The number of ports to be probed for an available port (TCP) | |
diag.ttl | string | TTL of the diagnostics multicast socket | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
linger | string | SO_LINGER in seconds. Default of -1 disables it | |
local_transport_class | string | The fully qualified name of a class implementing LocalTransport | |
log_details | string | Log a stack trace when a connection is closed | |
log_discard_msgs | string | whether or not warnings about messages from different groups are logged | |
log_discard_msgs_version | string | whether or not warnings about messages from members with a different version are discarded | |
logical_addr_cache_expiration | string | Time (in ms) after which entries in the logical address cache marked as removable can be removed. 0 never removes any entries (not recommended) | |
logical_addr_cache_max_size | string | Max number of elements in the logical address cache before eviction starts | |
logical_addr_cache_reaper_interval | string | Interval (in ms) at which the reaper task scans logical_addr_cache and removes entries marked as removable. 0 disables reaping. | |
loopback_copy | string | Whether or not to make a copy of a message before looping it back up. Don't use this; might get removed without warning | |
loopback_separate_thread | string | Loop back the message on a separate thread or use the current thread. Don't use this; might get removed without warning | |
max_length | string | The max number of bytes a message can have. If greater, an exception will be thrown. 0 disables this | |
max_send_buffers | string | The max number of outgoing messages that can get queued for a given peer connection (before dropping them). Most messages will get retransmitted; this is mainly used at startup, e.g. to prevent dropped discovery requests or responses (sent unreliably, without retransmission). | |
message_processing_policy | string | The fully qualified name of a class implementing MessageProcessingPolicy | |
msg_factory_class | string | The fully qualified name of a MessageFactory implementation | |
peer_addr_read_timeout | string | Max time to block on reading of peer address | |
policies | string | ||
port_range | string | The range of valid ports: [bind_port .. bind_port+port_range ]. 0 only binds to bind_port and fails if taken | |
reader_idle_time | string | Number of ms a reader thread on a given connection can be idle (not receiving any messages) until it terminates. New messages will start a new reader | |
reaper_interval | string | Reaper interval in msec. Default is 0 (no reaping) | |
receive_interfaces | string | Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
recv_buf_size | string | Receiver buffer size in bytes | |
send_buf_size | string | Send buffer size in bytes | |
sock_conn_timeout | string | Max time allowed for a socket creation in connection table | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_different_cluster_warnings | string | Time during which identical warnings about messages from a member from a different cluster will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_different_version_warnings | string | Time during which identical warnings about messages from a member with a different version will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
tcp_nodelay | string | Should TCP no delay flag be turned on | |
thread_naming_pattern | string | Thread naming pattern for threads in this channel. Valid values are "pcl": "p": includes the thread name, e.g. "Incoming thread-1", "UDP ucast receiver", "c": includes the cluster name, e.g. "MyCluster", "l": includes the local address of the current member, e.g. "192.168.5.1:5678" | |
thread_pool.delta | string | Added to the view size when the pool is increased dynamically | |
thread_pool.enabled | string | Whether or not the thread pool is enabled. If false, tasks will be run on the caller's thread | |
thread_pool.increase_max_size_dynamically | string | Increases max_threads by the view size + delta if enabled (https://issues.redhat.com/browse/JGRP-2655) | |
thread_pool.keep_alive_time | string | Timeout (ms) to remove idle threads from the pool | |
thread_pool.max_threads | string | Maximum thread pool size for the thread pool | |
thread_pool.min_threads | string | Minimum thread pool size for the thread pool | |
thread_pool.rejection_policy | string | The rejection policy to be used in the thread pool (abort, discard, run, custom etc. See Util.parseRejectionPolicy() for details | |
thread_pool.thread_dump_path | string | Path to which the thread dump will be written. Ignored if null | |
thread_pool.thread_dumps_threshold | string | The number of times a thread pool needs to be full before a thread dump is logged | |
time_service_interval | string | Interval (in ms) at which the time service updates its timestamp. 0 disables the time service | |
use_acks | string | Wait for an ack from the server when a connection is established (https://issues.redhat.com/browse/JGRP-2684) | |
use_virtual_threads | string | If true, create virtual threads, otherwise create native threads | |
who_has_cache_timeout | string | Timeout (in ms) to determine how long to wait until a request to fetch the physical address for a given logical address will be sent again. Subsequent requests for the same physical address will therefore be spaced at least who_has_cache_timeout ms apart |
THREAD_COUNT
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
down_threads | string | Enables the average for down threads | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
up_threads | string | Enables the average for up threads |
TIME
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
down_msgs | string | Enables or disables measuring times of messages sent down | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
up_batches | string | Enables or disables measuring times of message batches received from below | |
up_msgs | string | Enables or disables measuring times of messages received from below. Attribute up_batches has to be true, or else up_msgs will be ignored |
TRACE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
TUNNEL
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by this transport. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address | |
bind_port | string | The port to which the transport binds. Default of 0 binds to any (ephemeral) port. See also port_range | |
bundler.capacity | string | The max number of elements in a bundler if the bundler supports size limitations | |
bundler.flush_interval | string | Max interval (millis) at which the queued messages are sent | |
bundler.max_batch_size | string | The maximum number of messages per batch | |
bundler.max_size | string | Maximum number of bytes for messages to be queued until they are sent | |
bundler.max_threads | string | Max number of threads in thread pool | |
bundler.num_spins | string | Number of spins before a real lock is acquired | |
bundler.poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
bundler.remove_queue_size | string | The capacity of the remove queue | |
bundler.wait_strategy | string | The wait strategy: spin, yield, park, spin-park, spin-yield | |
bundler_type | string | The type of bundler used ("ring-buffer", "transfer-queue" (default), "sender-sends" or "no-bundler") or the fully qualified classname of a Bundler implementation | |
diag.bind_addr | string | Bind address for diagnostic probing, to bind the TCP socket. Used when enable_tcp is true | |
diag.bind_interfaces | string | Comma delimited list of interfaces (IP addrs or interface names) that the multicast socket should bind to | |
diag.enable_tcp | string | Use a TCP socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enable_udp | string | Use a multicast socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enabled | string | Switch to enable diagnostic probing | |
diag.mcast_addr | string | Multicast address for diagnostic probing (UDP MulticastSocket). Used when enable_udp is true | |
diag.passcode | string | Authorization passcode for diagnostics. If specified every probe query will be authorized | |
diag.port | string | Port for diagnostic probing. Default is 7500 | |
diag.port_range | string | The number of ports to be probed for an available port (TCP) | |
diag.ttl | string | TTL of the diagnostics multicast socket | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
gossip_router_hosts | string | A comma-separated list of GossipRouter hosts, e.g. HostA[12001],HostB[12001] | |
heartbeat_interval | string | Sends a heartbeat to the GossipRouter every heartbeat_interval ms (0 disables this) | |
heartbeat_timeout | string | Max time (ms) with no received message or heartbeat after which the connection to a GossipRouter is closed. Ignored when heartbeat_interval is 0. | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
local_transport_class | string | The fully qualified name of a class implementing LocalTransport | |
log_discard_msgs | string | whether or not warnings about messages from different groups are logged | |
log_discard_msgs_version | string | whether or not warnings about messages from members with a different version are discarded | |
logical_addr_cache_expiration | string | Time (in ms) after which entries in the logical address cache marked as removable can be removed. 0 never removes any entries (not recommended) | |
logical_addr_cache_max_size | string | Max number of elements in the logical address cache before eviction starts | |
logical_addr_cache_reaper_interval | string | Interval (in ms) at which the reaper task scans logical_addr_cache and removes entries marked as removable. 0 disables reaping. | |
loopback_copy | string | Whether or not to make a copy of a message before looping it back up. Don't use this; might get removed without warning | |
loopback_separate_thread | string | Loop back the message on a separate thread or use the current thread. Don't use this; might get removed without warning | |
message_processing_policy | string | The fully qualified name of a class implementing MessageProcessingPolicy | |
msg_factory_class | string | The fully qualified name of a MessageFactory implementation | |
policies | string | ||
port_range | string | The range of valid ports: [bind_port .. bind_port+port_range ]. 0 only binds to bind_port and fails if taken | |
receive_interfaces | string | Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
reconnect_interval | string | Interval in msec to attempt connecting back to router in case of torn connection | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_different_cluster_warnings | string | Time during which identical warnings about messages from a member from a different cluster will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_different_version_warnings | string | Time during which identical warnings about messages from a member with a different version will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
tcp_nodelay | string | Should TCP no delay flag be turned on | |
thread_naming_pattern | string | Thread naming pattern for threads in this channel. Valid values are "pcl": "p": includes the thread name, e.g. "Incoming thread-1", "UDP ucast receiver", "c": includes the cluster name, e.g. "MyCluster", "l": includes the local address of the current member, e.g. "192.168.5.1:5678" | |
thread_pool.delta | string | Added to the view size when the pool is increased dynamically | |
thread_pool.enabled | string | Whether or not the thread pool is enabled. If false, tasks will be run on the caller's thread | |
thread_pool.increase_max_size_dynamically | string | Increases max_threads by the view size + delta if enabled (https://issues.redhat.com/browse/JGRP-2655) | |
thread_pool.keep_alive_time | string | Timeout (ms) to remove idle threads from the pool | |
thread_pool.max_threads | string | Maximum thread pool size for the thread pool | |
thread_pool.min_threads | string | Minimum thread pool size for the thread pool | |
thread_pool.rejection_policy | string | The rejection policy to be used in the thread pool (abort, discard, run, custom etc. See Util.parseRejectionPolicy() for details | |
thread_pool.thread_dump_path | string | Path to which the thread dump will be written. Ignored if null | |
thread_pool.thread_dumps_threshold | string | The number of times a thread pool needs to be full before a thread dump is logged | |
time_service_interval | string | Interval (in ms) at which the time service updates its timestamp. 0 disables the time service | |
tls.cipher_suites | string | The list of cipher suites | |
tls.client_auth | string | Defines whether client certificate authentication is required. Legal values are NONE, WANT or NEED | |
tls.enabled | string | Enables TLS; when true, SSL sockets will be used instead of regular sockets | |
tls.keystore_alias | string | Alias used for fetching the key | |
tls.keystore_password | string | Keystore password | |
tls.keystore_path | string | Fully qualified path to the keystore | |
tls.keystore_type | string | The type of the keystore | |
tls.protocols | string | One or more TLS protocol names to use, e.g. TLSv1.2. Setting this requires configuring key and trust stores | |
tls.provider | string | The security provider. Defaults to null, which will use the default JDK provider | |
tls.sni_matchers | string | A list of regular expression that servers use to match and accept SNI host names | |
tls.truststore_password | string | The password of the truststore | |
tls.truststore_path | string | Fully qualified path to the truststore | |
tls.truststore_type | string | The type of the truststore | |
use_nio | string | Whether to use blocking (false) or non-blocking (true) connections. If GossipRouter is used, this needs to be false; if GossipRouterNio is used, it needs to be true | |
use_virtual_threads | string | If true, create virtual threads, otherwise create native threads | |
who_has_cache_timeout | string | Timeout (in ms) to determine how long to wait until a request to fetch the physical address for a given logical address will be sent again. Subsequent requests for the same physical address will therefore be spaced at least who_has_cache_timeout ms apart |
UDP
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The bind address which should be used by this transport. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address | |
bind_port | string | The port to which the transport binds. Default of 0 binds to any (ephemeral) port. See also port_range | |
bundler.capacity | string | The max number of elements in a bundler if the bundler supports size limitations | |
bundler.flush_interval | string | Max interval (millis) at which the queued messages are sent | |
bundler.max_batch_size | string | The maximum number of messages per batch | |
bundler.max_size | string | Maximum number of bytes for messages to be queued until they are sent | |
bundler.max_threads | string | Max number of threads in thread pool | |
bundler.num_spins | string | Number of spins before a real lock is acquired | |
bundler.poll_timeout | string | Time (microseconds) to wait on poll() from the down_queue. A value of <= 0 doesn't wait | |
bundler.remove_queue_size | string | The capacity of the remove queue | |
bundler.wait_strategy | string | The wait strategy: spin, yield, park, spin-park, spin-yield | |
bundler_type | string | The type of bundler used ("ring-buffer", "transfer-queue" (default), "sender-sends" or "no-bundler") or the fully qualified classname of a Bundler implementation | |
diag.bind_addr | string | Bind address for diagnostic probing, to bind the TCP socket. Used when enable_tcp is true | |
diag.bind_interfaces | string | Comma delimited list of interfaces (IP addrs or interface names) that the multicast socket should bind to | |
diag.enable_tcp | string | Use a TCP socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enable_udp | string | Use a multicast socket to listen for probe requests (ignored if diag.enabled is false) | |
diag.enabled | string | Switch to enable diagnostic probing | |
diag.mcast_addr | string | Multicast address for diagnostic probing (UDP MulticastSocket). Used when enable_udp is true | |
diag.passcode | string | Authorization passcode for diagnostics. If specified every probe query will be authorized | |
diag.port | string | Port for diagnostic probing. Default is 7500 | |
diag.port_range | string | The number of ports to be probed for an available port (TCP) | |
diag.ttl | string | TTL of the diagnostics multicast socket | |
disable_loopback | string | If true, disables IP_MULTICAST_LOOP on the MulticastSocket (for sending and receiving of multicast packets). IP multicast packets send on a host P will therefore not be received by anyone on P. Use with caution. | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
ip_mcast | string | Multicast toggle. If false multiple unicast datagrams are sent instead of one multicast. Default is true | |
ip_ttl | string | The time-to-live (TTL) for multicast datagram packets. Default is 8 | |
level | string | logger level (see javadocs) | |
local_transport_class | string | The fully qualified name of a class implementing LocalTransport | |
log_discard_msgs | string | whether or not warnings about messages from different groups are logged | |
log_discard_msgs_version | string | whether or not warnings about messages from members with a different version are discarded | |
logical_addr_cache_expiration | string | Time (in ms) after which entries in the logical address cache marked as removable can be removed. 0 never removes any entries (not recommended) | |
logical_addr_cache_max_size | string | Max number of elements in the logical address cache before eviction starts | |
logical_addr_cache_reaper_interval | string | Interval (in ms) at which the reaper task scans logical_addr_cache and removes entries marked as removable. 0 disables reaping. | |
loopback_copy | string | Whether or not to make a copy of a message before looping it back up. Don't use this; might get removed without warning | |
loopback_separate_thread | string | Loop back the message on a separate thread or use the current thread. Don't use this; might get removed without warning | |
mcast_addr | string | The multicast address used for sending and receiving packets | |
mcast_port | string | The multicast port used for sending and receiving packets. Default is 7600 | |
mcast_receiver_threads | string | Number of multicast receiver threads, all reading from the same MulticastSocket. If de-serialization is slow, increasing the number of receiver threads might yield better performance. | |
mcast_recv_buf_size | string | Receive buffer size of the multicast datagram socket | |
mcast_send_buf_size | string | Send buffer size of the multicast datagram socket | |
message_processing_policy | string | The fully qualified name of a class implementing MessageProcessingPolicy | |
msg_factory_class | string | The fully qualified name of a MessageFactory implementation | |
policies | string | ||
port_range | string | The range of valid ports: [bind_port .. bind_port+port_range ]. 0 only binds to bind_port and fails if taken | |
receive_interfaces | string | Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on | |
receive_on_all_interfaces | string | If true, the transport should use all available interfaces to receive multicast messages | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_different_cluster_warnings | string | Time during which identical warnings about messages from a member from a different cluster will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_different_version_warnings | string | Time during which identical warnings about messages from a member with a different version will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
suppress_time_out_of_buffer_space | string | Suppresses warnings on Mac OS (for now) about not enough buffer space when sending a datagram packet | |
thread_naming_pattern | string | Thread naming pattern for threads in this channel. Valid values are "pcl": "p": includes the thread name, e.g. "Incoming thread-1", "UDP ucast receiver", "c": includes the cluster name, e.g. "MyCluster", "l": includes the local address of the current member, e.g. "192.168.5.1:5678" | |
thread_pool.delta | string | Added to the view size when the pool is increased dynamically | |
thread_pool.enabled | string | Whether or not the thread pool is enabled. If false, tasks will be run on the caller's thread | |
thread_pool.increase_max_size_dynamically | string | Increases max_threads by the view size + delta if enabled (https://issues.redhat.com/browse/JGRP-2655) | |
thread_pool.keep_alive_time | string | Timeout (ms) to remove idle threads from the pool | |
thread_pool.max_threads | string | Maximum thread pool size for the thread pool | |
thread_pool.min_threads | string | Minimum thread pool size for the thread pool | |
thread_pool.rejection_policy | string | The rejection policy to be used in the thread pool (abort, discard, run, custom etc. See Util.parseRejectionPolicy() for details | |
thread_pool.thread_dump_path | string | Path to which the thread dump will be written. Ignored if null | |
thread_pool.thread_dumps_threshold | string | The number of times a thread pool needs to be full before a thread dump is logged | |
time_service_interval | string | Interval (in ms) at which the time service updates its timestamp. 0 disables the time service | |
tos | string | Traffic class for sending unicast and multicast datagrams | |
ucast_receiver_threads | string | Number of unicast receiver threads, all reading from the same DatagramSocket. If de-serialization is slow, increasing the number of receiver threads might yield better performance. | |
ucast_recv_buf_size | string | Receive buffer size of the unicast datagram socket | |
ucast_send_buf_size | string | Send buffer size of the unicast datagram socket | |
use_virtual_threads | string | If true, create virtual threads, otherwise create native threads | |
who_has_cache_timeout | string | Timeout (in ms) to determine how long to wait until a request to fetch the physical address for a given logical address will be sent again. Subsequent requests for the same physical address will therefore be spaced at least who_has_cache_timeout ms apart |
UFC
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_block_time | string | Max time (in ms) to block | |
max_credits | string | Max number of bytes to send per receiver until an ack must be received to proceed | |
min_credits | string | Computed as max_credits x min_theshold unless explicitly set | |
min_threshold | string | The threshold (as a percentage of max_credits) at which a receiver sends more credits to a sender. Example: if max_credits is 1'000'000, and min_threshold 0.25, then we send ca. 250'000 credits to P once we've got only 250'000 credits left for P (we've received 750'000 bytes from P) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
UFC_NB
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_block_time | string | Max time (in ms) to block | |
max_credits | string | Max number of bytes to send per receiver until an ack must be received to proceed | |
max_queue_size | string | Max number of bytes of all queued messages for a given destination. If a given destination has no credits left and the message cannot be added to the queue because it is full, then the sender thread will be blocked until there is again space available in the queue, or the protocol is stopped. | |
min_credits | string | Computed as max_credits x min_theshold unless explicitly set | |
min_threshold | string | The threshold (as a percentage of max_credits) at which a receiver sends more credits to a sender. Example: if max_credits is 1'000'000, and min_threshold 0.25, then we send ca. 250'000 credits to P once we've got only 250'000 credits left for P (we've received 750'000 bytes from P) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
UNICAST3
Name | Type | Default | Description |
---|---|---|---|
ack_threshold | string | Send an ack immediately when a batch of ack_threshold (or more) messages is received. Otherwise send delayed acks. If 1, ack single messages (similar to UNICAST) | |
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
conn_close_timeout | string | Time (in ms) until a connection marked to be closed will get removed. 0 disables this | |
conn_expiry_timeout | string | Time (in milliseconds) after which an idle incoming or outgoing connection is closed. The connection will get re-established when used again. 0 disables connection reaping. Note that this creates lingering connection entries, which increases memory over time. | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
log_not_found_msgs | string | If true, trashes warnings about retransmission messages not found in the xmit_table (used for testing) | |
loopback | string | If true, a unicast message to self is looped back up on the same thread. Noter that this may cause problems (e.g. deadlocks) in some applications, so make sure that your code can handle this. Issue: https://issues.redhat.com/browse/JGRP-2547 | |
max_batch_size | string | The max size of a message batch when delivering messages. 0 is unbounded | |
max_retransmit_time | string | Max number of milliseconds we try to retransmit a message to any given member. After that, the connection is removed. Any new connection to that member will start with seqno #1 again. 0 disables this | |
max_xmit_req_size | string | Max number of messages to ask for in a retransmit request. 0 disables this and uses the max bundle size in the transport | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
sync_min_interval | string | Min time (in ms) to elapse for successive SEND_FIRST_SEQNO messages to be sent to the same sender | |
xmit_interval | string | Interval (in milliseconds) at which messages in the send windows are resent | |
xmit_table_max_compaction_time | string | Number of milliseconds after which the matrix in the retransmission table is compacted (only for experts) | |
xmit_table_msgs_per_row | string | Number of elements of a row of the matrix in the retransmission table; gets rounded to the next power of 2 (only for experts). The capacity of the matrix is xmit_table_num_rows * xmit_table_msgs_per_row | |
xmit_table_num_rows | string | Number of rows of the matrix in the retransmission table (only for experts) | |
xmit_table_resize_factor | string | Resize factor of the matrix in the retransmission table (only for experts) | |
xmits_enabled | string | When true, the sender retransmits messages until ack'ed and the receiver asks for missing messages. When false, this is not done, but ack'ing and stale connection testing is still done. https://issues.redhat.com/browse/JGRP-2676 |
VERIFY_SUSPECT
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | Interface for ICMP pings. Used if use_icmp is true The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
num_msgs | string | Number of verify heartbeats sent to a suspected member | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Number of millisecs to wait for a response from a suspected member | |
use_icmp | string | Use InetAddress.isReachable() to verify suspected member instead of regular messages | |
use_mcast_rsps | string | Send the I_AM_NOT_DEAD message back as a multicast rather than as multiple unicasts (default is false) |
VERIFY_SUSPECT2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
num_msgs | string | Number of verify heartbeats sent to a suspected member | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Number of millis to wait for verification that a suspect is really dead (approximation) | |
use_mcast_rsps | string | Send the I_AM_NOT_DEAD message back as a multicast rather than as multiple unicasts (default is false) |
pbcast.FLUSH
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bypass | string | When set, FLUSH is bypassed, same effect as if FLUSH wasn't in the config at all | |
enable_reconciliation | string | Reconciliation phase toggle. Default is true | |
end_flush_timeout | string | Timeout to wait for UNBLOCK after STOP_FLUSH is issued. Default is 2000 msec | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
retry_timeout | string | Retry timeout after an unsuccessful attempt to quiet the cluster (first flush phase).Default is 3000 msec | |
start_flush_timeout | string | Timeout (per atttempt) to quiet the cluster during the first flush phase. Default is 2000 msec | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
timeout | string | Max time to keep channel blocked in flush. Default is 8000 msec |
pbcast.GMS
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
all_clients_retry_timeout | string | Time (in ms) to wait for another discovery round when all discovery responses were clients. A timeout of 0 means don't wait at all. | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
join_timeout | string | Join timeout | |
leave_timeout | string | Max time (in ms) to wait for a LEAVE response after a LEAVE req has been sent to the coord | |
level | string | logger level (see javadocs) | |
log_collect_msgs | string | Logs failures for collecting all view acks if true | |
log_view_warnings | string | Logs warnings for reception of views less than the current, and for views which don't include self | |
max_join_attempts | string | Number of join attempts before we give up and become a singleton. 0 means 'never give up' | |
max_leave_attempts | string | Number of times a LEAVE request is sent to the coordinator (without receiving a LEAVE response, before giving up and leaving anyway (failure detection will eventually exclude the left member). A value of 0 means wait forever | |
membership_change_policy | string | The fully qualified name of a class implementing MembershipChangePolicy. | |
merge_timeout | string | Timeout (in ms) to complete merge | |
num_prev_mbrs | string | Max number of old members to keep in history. Default is 50 | |
num_prev_views | string | Number of views to store in history | |
policies | string | ||
print_local_addr | string | Print local address of this member after connect. Default is true | |
print_physical_addrs | string | Print physical address(es) on startup | |
print_view_details | string | When true, left and joined members are printed in addition to the view | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_delta_views | string | If true, then GMS is allowed to send VIEW messages with delta views, otherwise it always sends full views. See https://issues.redhat.com/browse/JGRP-1354 for details. | |
use_flush_if_present | string | Use flush for view changes. Default is true | |
view_ack_collection_timeout | string | Time in ms to wait for all VIEW acks (0 == wait forever. Default is 2000 msec |
pbcast.NAKACK2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
become_server_queue_size | string | Size of the queue to hold messages received after creating the channel, but before being connected (is_server=false). After becoming the server, the messages in the queue are fed into up() and the queue is cleared. The motivation is to avoid retransmissions (see https://issues.redhat.com/browse/JGRP-1509 for details). | |
discard_delivered_msgs | string | Should messages delivered to application be discarded | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
log_discard_msgs | string | discards warnings about promiscuous traffic | |
log_not_found_msgs | string | If false, trashes warnings about retransmission messages not found in the xmit_table (used for testing) | |
max_batch_size | string | The max size of a message batch when delivering messages. 0 is unbounded | |
max_rebroadcast_timeout | string | Timeout to rebroadcast messages. Default is 2000 msec | |
max_xmit_req_size | string | Max number of messages to ask for in a retransmit request. 0 disables this and uses the max bundle size in the transport | |
policies | string | ||
resend_last_seqno | string | If enabled, multicasts the highest sent seqno every xmit_interval ms. This is skipped if a regular message has been multicast, and the task aquiesces if the highest sent seqno hasn't changed for resend_last_seqno_max_times times. Used to speed up retransmission of dropped last messages (JGRP-1904) | |
resend_last_seqno_max_times | string | Max number of times the last seqno is resent before acquiescing if last seqno isn't incremented | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_non_member_warnings | string | Time during which identical warnings about messages from a non member will be suppressed. 0 disables this (every warning will be logged). Setting the log level to ERROR also disables this. | |
use_mcast_xmit | string | Retransmit retransmit responses (messages) using multicast rather than unicast | |
use_mcast_xmit_req | string | Use a multicast to request retransmission of missing messages | |
xmit_from_random_member | string | Ask a random member for retransmission of a missing message. Default is false | |
xmit_interval | string | Interval (in milliseconds) at which missing messages (from all retransmit buffers) are retransmitted. 0 turns retransmission off | |
xmit_table_max_compaction_time | string | Number of milliseconds after which the matrix in the retransmission table is compacted (only for experts) | |
xmit_table_msgs_per_row | string | Number of elements of a row of the matrix in the retransmission table; gets rounded to the next power of 2 (only for experts). The capacity of the matrix is xmit_table_num_rows * xmit_table_msgs_per_row | |
xmit_table_num_rows | string | Number of rows of the matrix in the retransmission table (only for experts) | |
xmit_table_resize_factor | string | Resize factor of the matrix in the retransmission table (only for experts) |
pbcast.STABLE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
desired_avg_gossip | string | Average time to send a STABLE message | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_bytes | string | Maximum number of bytes received in all messages before sending a STABLE message is triggered | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
pbcast.STATE
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
buffer_size | string | Size (in bytes) of the state transfer buffer | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_pool | string | Maximum number of pool threads serving state requests | |
policies | string | ||
pool_thread_keep_alive | string | Keep alive for pool threads serving state requests | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
pbcast.STATE_SOCK
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
bind_addr | string | The interface (NIC) used to accept state requests. The following special values are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK | |
bind_interface | string | The interface (NIC) which should be used by this transport | |
bind_port | string | The port listening for state requests. Default value of 0 binds to any (ephemeral) port | |
buffer_size | string | Size (in bytes) of the state transfer buffer | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
external_addr | string | Use "external_addr" if you have hosts on different networks, behind firewalls. On each firewall, set up a port forwarding rule (sometimes called "virtual server") to the local IP (e.g. 192.168.1.100) of the host then on each host, set "external_addr" TCP transport parameter to the external (public IP) address of the firewall. | |
external_port | string | Used to map the internal port (bind_port) to an external port. Only used if > 0 | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_pool | string | Maximum number of pool threads serving state requests | |
policies | string | ||
pool_thread_keep_alive | string | Keep alive for pool threads serving state requests | |
recv_buf_size | string | The size (in bytes) of the receive buffer of the socket | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
pbcast.STATE_TRANSFER
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
policies | string | ||
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true |
relay.RELAY2
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_relay_creation | string | If true, the creation of the relay channel (and the connect()) are done in the background. Async relay creation is recommended, so the view callback won't be blocked | |
can_become_site_master | string | Whether or not this node can become the site master. If false, and we become the coordinator, we won't start the bridge(s) | |
can_forward_local_cluster | string | If true, a site master forwards messages received from other sites to randomly chosen members of the local site for load balancing, reducing work for itself | |
config | string | Name of the relay configuration | |
enable_address_tagging | string | Whether or not we generate our own addresses in which we use can_become_site_master. If this property is false, can_become_site_master is ignored | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_site_masters | string | Maximum number of site masters. Setting this to a value greater than 1 means that we can have multiple site masters. If the value is greater than the number of cluster nodes, everyone in the site will be a site master (and thus join the global cluster | |
policies | string | ||
relay_multicasts | string | Whether or not to relay multicast (dest=null) messages | |
site | string | Name of the site (needs to be defined in the configuration) | |
site_master_picker_impl | string | Fully qualified name of a class implementing SiteMasterPicker | |
site_masters_ratio | string | Ratio of members that are site masters, out of range [0..1] (0 disables this). The number of site masters is computes as Math.min(max_site_masters, view.size() * site_masters_ratio). See https://issues.redhat.com/browse/JGRP-2581 for details | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
suppress_time_no_route_errors | string | Time during which identical errors about no route to host will be suppressed. 0 disables this (every error will be logged). | |
topo_wait_time | string | Number of millis to wait for topology detection |
RelayConfiguration
dns.DNS_PING
Name | Type | Default | Description |
---|---|---|---|
after_creation_hook | string | Fully qualified name of a class implementing ProtocolHook, will be called after creation of the protocol (before init()) | |
async_discovery | string | If true then the discovery is done on a separate timer thread. Should be set to true when discovery is blocking and/or takes more than a few milliseconds | |
async_discovery_use_separate_thread_per_request | string | If enabled, use a separate thread for every discovery request. Can be used with or without async_discovery | |
break_on_coord_rsp | string | Return from the discovery phase as soon as we have 1 coordinator response | |
discovery_rsp_expiry_time | string | Expiry time of discovery responses in ms | |
dns_address | string | DNS Address. This property will be assembled with the 'dns://' prefix. If this is specified, A records will be resolved through DnsContext. | |
dns_context_factory | string | DNS Context Factory. Used when DNS_PING is configured to use SRV record types and when using A types with a specific dns_address. | |
dns_query | string | A comma-separated list of DNS queries for fetching members | |
dns_record_type | string | DNS Record type | |
ergonomics | string | Enables ergonomics: dynamically find the best values for properties at runtime | |
id | string | Give the protocol a different ID if needed so we can have multiple instances of it in the same stack | |
level | string | logger level (see javadocs) | |
max_members_in_discovery_request | string | Max size of the member list shipped with a discovery request. If we have more, the mbrs field in the discovery request header is nulled and members return the entire membership, not individual members | |
max_rank_to_reply | string | The max rank of this member to respond to discovery requests, e.g. if max_rank_to_reply=2 in {A,B,C,D,E}, only A (rank 1) and B (rank 2) will reply. A value <= 0 means everybody will reply. This attribute is ignored if TP.use_ip_addrs is false. | |
num_discovery_runs | string | The number of times a discovery process is executed when finding initial members (https://issues.redhat.com/browse/JGRP-2317) | |
policies | string | ||
probe_transport_ports | string | For SRV records returned by the DNS query, the non-0 ports returned by DNS areused. If this attribute is true, then the transport ports will also be used. Ignored for A records. | |
return_entire_cache | string | Whether or not to return the entire logical-physical address cache mappings on a discovery request, or not. | |
send_cache_on_join | string | When a new node joins, and we have a static discovery protocol (TCPPING), then send the contents of the discovery cache to new and existing members if true (and we're the coord). Addresses JGRP-1903 | |
stagger_timeout | string | If greater than 0, we'll wait a random number of milliseconds in range [0..stagger_timeout] before sending a discovery response. This prevents traffic spikes in large clusters when everyone sends their discovery response at the same time | |
stats | string | Determines whether to collect statistics (and expose them via JMX). Default is true | |
use_disk_cache | string | If a persistent disk cache (PDC) is present, combine the discovery results with the contents of the disk cache before returning the results |
threads?
Defines the threading subsystem.
The threading subsystem, used to declare manageable thread pools and resources.thread-factory*
Name | Type | Default | Description |
---|---|---|---|
name | string | ||
group-name | string | ||
thread-name-pattern | string | ||
priority | string |
blocking-bounded-queue-thread-pool*
Name | Type | Default | Description |
---|---|---|---|
name | string | ||
thread-factory | string | ||
max-threads | int | ||
core-threads | int | ||
keepalive-time | string | ||
queue-length | string |
non-blocking-bounded-queue-thread-pool*
Name | Type | Default | Description |
---|---|---|---|
name | string | ||
thread-factory | string | ||
max-threads | int | ||
core-threads | int | ||
keepalive-time | string | ||
queue-length | string |
cached-thread-pool*
Name | Type | Default | Description |
---|---|---|---|
name | string | ||
thread-factory | string |
scheduled-thread-pool*
Name | Type | Default | Description |
---|---|---|---|
name | string | ||
thread-factory | string |
cache-container
Defines an embedded cache container.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
name | string | Uniquely identifies this cache container. | |||||||
jndi-name | string | Unused XML attribute | |||||||
default-cache | string | Indicates the default cache for this cache container | |||||||
zero-capacity-node | boolean | false | If 'true' then no data is stored in this node. Defaults to 'false'. | ||||||
start | FIXME | Unused XML attribute | |||||||
listener-executor | string | Defines the executor used for asynchronous cache listener notifications. | |||||||
expiration-executor | string | Defines the scheduled executor used for expirations. | |||||||
non-blocking-executor | string | The name of the executor used for non-blocking operations. Must be non-blocking and must have a queue. | |||||||
blocking-executor | string | The name of the executor used for blocking operations. Must be blocking and must have a queue. | |||||||
module | string | org.jboss.as.clustering.infinispan | Unused XML attribute | ||||||
statistics | boolean | false | Determines whether or not the cache container should collect statistics. Keep disabled for optimal performance. | ||||||
shutdown-hook |
| Behavior of the JVM shutdown hook registered by the cache |
transport?
Overrides the transport characteristics for this cache container.
Name | Type | Default | Description |
---|---|---|---|
stack | string | Defines the jgroups stack used by the transport. | |
cluster | string | Defines the name for the underlying group communication cluster. | |
lock-timeout | long | 240000 | Infinispan uses a distributed lock to maintain a coherent transaction log during state transfer or rehashing, which means that only one cache can be doing state transfer or rehashing at the same time. This constraint is in place because more than one cache could be involved in a transaction. This timeout controls the time to wait to acquire a distributed lock. |
node-name | string | Specifies the name of the current node. Defaults to a combination of the host name and a random number to differentiate between multiple nodes on the same host. | |
machine | string | Specifies the ID of the machine where the node runs. When a single physical machine hosts multiple JVM instances, the machine ID ensures that data is distributed across different physical hosts. | |
rack | string | Specifies the ID of the rack where the node runs. The rack ID ensures that the copies of data are stored on different rack than the original data. | |
site | string | The ID of the site where the node runs.In clusters with nodes in multiple physical locations site ID ensures that backup copies of data are stored across different locations. | |
initial-cluster-size | int | The minimum number of nodes that must join the cluster for the cache manager to start | |
initial-cluster-timeout | long | The amount of time in milliseconds to wait for a cluster with sufficient nodes to form. Defaults to 60000 | |
raft-members | string | The list of raft members separated by space. |
property*
A transport property with name and value to be passed to the Transport instance.
security?
Configures security for this cache container.
Name | Type | Default | Description |
---|---|---|---|
cache-size | int | The ACL cache size. The default is 1000 entries. A value of 0 disables the cache. | |
cache-timeout | long | The ACL cache timeout in milliseconds. The default is 300000 (5 minutes). A value of 0 disables the cache. |
authorization?
Configures the global authorization role to permission mapping. The presence of this element in the configuration implicitly enables authorization.
Name | Type | Default | Description |
---|---|---|---|
audit-logger | string | Class of the audit logger. |
cluster-permission-mapper
Stores role to permission mappings in the cluster registry. This role mapper is enabled by default in the server configuration.
custom-permission-mapper
Configures a custom permission mapper implementation.
Name | Type | Default | Description |
---|---|---|---|
class | string | Specifies the class name of a custom implementation that maps roles to permissions. |
identity-role-mapper
Uses the identity role mapper where principal names are converted as-is into role names.
common-name-role-mapper
Uses the common name role mapper which assumes principal names are in Distinguished Name format and extracts the Common Name to use as a role.
cluster-role-mapper
Stores the principal to role mappings in the cluster registry. This role mapper is enabled by default in the server configuration.
custom-role-mapper
Configures a custom role mapper.
Name | Type | Default | Description |
---|---|---|---|
class | string | Specifies the class name of a custom principal to role mapper implementation. |
roles?
role*
Defines a new role name and assigns permissions to it.
Name | Type | Default | Description | ||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
name | string | Defines the name of the role. | |||||||||||||||||||||||||
permissions |
| Defines the list of permissions for the role. |
serialization?
Specifies how data serialization will be performed by the cache container.
Name | Type | Default | Description |
---|---|---|---|
marshaller | string | Fully qualified name of the marshaller to use. It must implement org.infinispan.marshall.StreamingMarshaller | |
version | string | 71 | Largest allowable version to use when marshalling internal state. Set this to the lowest version cache instance in your cluster to ensure compatibility of communications. However, setting this too low will mean you lose out on the benefit of improvements in newer versions of the marshaller. |
advanced-externalizer*
Deprecated since 10.0. Please utilise ProtoStream based marshalling for your Java objects by configuring one or more context-initializer elements. Alternatively, it's possible to configure a custom org.infinispan.commons.marshall.Marshaller implementation for user types, via the "marshaller" attribute. AdvancedExternalizer implementations allow users to have fine grained control over how Java objects are serialized. Providing smaller payloads than traditional Serialization or Externalizer implementations by writing a class ID value instead of the classes FQN.
Name | Type | Default | Description |
---|---|---|---|
class | string | Class of the custom externalizer | |
id | int | Id of the custom externalizer |
context-initializer*
SerializationContextInitializer implementation which is used to initialize a ProtoStream based marshaller for user types. If no <context-initializer> elements are present then the java.util.ServiceLoader mechanism will be used to automatically discover all SerializationContextInitializer implementations present in classpath and load them.
Name | Type | Default | Description |
---|---|---|---|
class | string | Class of the SerializationContextInitializer implementation |
allow-list?
Enables individual classes or regular expressions to be added to the EmbeddedCacheManager allow list.
class*
FQN of the class to be added to the allowlist.
regex*
Regex pattern used to determine if a class is a member of the allowlist.
metrics?
Configures metrics.
Name | Type | Default | Description |
---|---|---|---|
gauges | boolean | true | Exports gauge metrics. Gauges are enabled by default but you must enable statistics so that they are exported. |
histograms | boolean | false | Exports histogram metrics. Histograms are not enabled by default because they require additional computation. If you enable histograms you must also enable statistics so that they are exported. |
prefix | string | Specifies a global name prefix for metrics. | |
names-as-tags | boolean | false | Put the cache manager and cache name in tags rather than include them in the metric name. |
accurate-size | boolean | false | Enables accurate size computation for numberOfEntries statistics. Note that this doesn't affect invocations of Cache#size() method. |
jmx?
Enables and configures JMX monitoring and management.
Name | Type | Default | Description |
---|---|---|---|
domain | string | org.infinispan | If JMX statistics are enabled then all 'published' JMX objects appear under this domain. Optional, if not specified it defaults to "org.infinispan". |
mbean-server-lookup | string | Class that attempts to locate a JMX MBean server to bind to. Defaults to the platform MBean server. | |
enabled | boolean | false | Enables exporting of JMX MBeans. |
property*
Specifies a JMX property with a name and value that is passed to the MBean Server lookup instance.
global-state?
Defines the global state persistence configuration. If this element is not present, global state persistence will be disabled.
persistent-location?
Defines the filesystem path where persistent state data which needs to survive container restarts should be stored. The data stored at this location is required for graceful shutdown and restore. This path must NOT be shared among multiple instances. Defaults to the user.dir system property which usually is where the application was started. This value should be overridden to a more appropriate location.
Name | Type | Default | Description |
---|---|---|---|
relative-to | string | jboss.server.data.dir | A property name whose value will be used as the root path for storing global state |
path | string | Defines the path where global state for this cache-container will be stored. |
shared-persistent-location?
Defines the filesystem path where shared persistent state data which needs to survive container restarts should be stored. This path can be safely shared among multiple instances. Defaults to the user.dir system property which usually is where the application was started. This value should be overridden to a more appropriate location.
Name | Type | Default | Description |
---|---|---|---|
relative-to | string | jboss.server.data.dir | A property name whose value will be used as the root path for storing global state |
path | string | Defines the path where global state for this cache-container will be stored. |
temporary-location?
Defines the filesystem path where temporary state should be stored. Defaults to the value of the java.io.tmpdir system property.
Name | Type | Default | Description |
---|---|---|---|
relative-to | string | jboss.server.data.dir | A property name whose value will be used as the root path for storing global state |
path | string | Defines the path where global state for this cache-container will be stored. |
immutable-configuration-storage
An immutable configuration storage.
volatile-configuration-storage
A non-persistent configuration storage.
overlay-configuration-storage
A persistent configuration storage which saves runtime configurations to the persistent-location.
managed-configuration-storage
A persistent configuration storage for managed environments. This doesn't work in embedded mode.
custom-configuration-storage
Uses a custom configuration storage implementation.
Name | Type | Default | Description |
---|---|---|---|
class | string | Class of the custom configuration storage implementation. |
local-cache
Defines a LOCAL mode cache.
Name | Type | Default | Description |
---|---|---|---|
simple-cache | FIXME | false | This cache will be using optimized (faster) implementation that does not support transactions/invocation batching, persistence, custom interceptors, indexing, store-as-binary or transcoding. Also, this type of cache does not support Map-Reduce jobs or Distributed Executor framework. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
local-cache-configuration
Defines a LOCAL mode cache configuration.
Name | Type | Default | Description |
---|---|---|---|
simple-cache | FIXME | false | This cache will be using optimized (faster) implementation that does not support transactions/invocation batching, persistence, custom interceptors, indexing, store-as-binary or transcoding. Also, this type of cache does not support Map-Reduce jobs or Distributed Executor framework. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
replicated-cache
Defines a REPL_* mode cache.
Name | Type | Default | Description |
---|---|---|---|
segments | int | 256 | Sets the number of hash space segments per cluster. The default value is 256. The value should be at least 20 * the cluster size. |
consistent-hash-factory | string | Deprecated since 11.0. Will be removed in 14.0, the segment allocation will no longer be customizable. The factory to use for generating the consistent hash. Must implement `org.infinispan.distribution.ch.ConsistentHashFactory`. E.g. `org.infinispan.distribution.ch.impl.SyncConsistentHashFactory` can be used to guarantee that multiple distributed caches use exactly the same consistent hash, which for performance reasons is not guaranteed by the default consistent hash factory instance used. | |
key-partitioner | string | The name of the key partitioner class. Must implement `org.infinispan.distribution.ch.KeyPartitioner`. A custom key partitioner can be used as an alternative to grouping, to guarantee that some keys are located in the same segment (and thus their primary owner is the same node). Since 8.2. |
state-transfer?
The state transfer configuration for distribution and replicated caches.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | true | If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time. |
timeout | long | 240000 | The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. Must be greater than or equal to 'remote-timeout' in the clustering configuration. |
chunk-size | integer | 512 | The number of cache entries to batch in each transfer. |
await-initial-transfer | boolean | true | If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests. |
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
replicated-cache-configuration
Defines a REPL_* mode cache configuration.
Name | Type | Default | Description |
---|---|---|---|
segments | int | 256 | Sets the number of hash space segments per cluster. The default value is 256. The value should be at least 20 * the cluster size. |
consistent-hash-factory | string | Deprecated since 11.0. Will be removed in 14.0, the segment allocation will no longer be customizable. The factory to use for generating the consistent hash. Must implement `org.infinispan.distribution.ch.ConsistentHashFactory`. E.g. `org.infinispan.distribution.ch.impl.SyncConsistentHashFactory` can be used to guarantee that multiple distributed caches use exactly the same consistent hash, which for performance reasons is not guaranteed by the default consistent hash factory instance used. | |
key-partitioner | string | The name of the key partitioner class. Must implement `org.infinispan.distribution.ch.KeyPartitioner`. A custom key partitioner can be used as an alternative to grouping, to guarantee that some keys are located in the same segment (and thus their primary owner is the same node). Since 8.2. |
state-transfer?
The state transfer configuration for distribution and replicated caches.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | true | If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time. |
timeout | long | 240000 | The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. Must be greater than or equal to 'remote-timeout' in the clustering configuration. |
chunk-size | integer | 512 | The number of cache entries to batch in each transfer. |
await-initial-transfer | boolean | true | If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests. |
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
invalidation-cache
Defines an INVALIDATION_* mode cache.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
invalidation-cache-configuration
Defines an INVALIDATION_* mode cache configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
distributed-cache
Defines a DIST_* mode cache.
Name | Type | Default | Description |
---|---|---|---|
owners | int | 2 | Number of cluster-wide replicas for each cache entry. |
segments | int | 256 | Sets the number of hash space segments per cluster. The default value is 256. The value should be at least 20 * the cluster size. |
capacity-factor | double | 1.0 | Controls the proportion of entries that reside on the local node in comparison to other nodes in the cluster. You must specify a positive number as the value. The value can also be a fraction such as 1.5. |
l1-lifespan | long | Maximum lifespan in milliseconds of an entry placed in the L1 cache. By default L1 is disabled unless a positive value is configured for this attribute. If the attribute is not present, L1 is disabled. | |
l1-cleanup-interval | long | 60000 | Controls how often a cleanup task to prune L1 tracking data is run. Defaults to 10 minutes. |
consistent-hash-factory | string | The factory to use for generating the consistent hash. Must implement `org.infinispan.distribution.ch.ConsistentHashFactory`. E.g. `org.infinispan.distribution.ch.impl.SyncConsistentHashFactory` can be used to guarantee that multiple distributed caches use exactly the same consistent hash, which for performance reasons is not guaranteed by the default consistent hash factory instance used. | |
key-partitioner | string | The name of the key partitioner class. Must implement `org.infinispan.distribution.ch.KeyPartitioner`. A custom key partitioner can be used as an alternative to grouping, to guarantee that some keys are located in the same segment (and thus their primary owner is the same node). Since 8.2. |
state-transfer?
The state transfer configuration for distribution and replicated caches.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | true | If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time. |
timeout | long | 240000 | The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. Must be greater than or equal to 'remote-timeout' in the clustering configuration. |
chunk-size | integer | 512 | The number of cache entries to batch in each transfer. |
await-initial-transfer | boolean | true | If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests. |
groups?
Configures grouping of data.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | Enables or disables grouping. |
grouper*
Name | Type | Default | Description |
---|---|---|---|
class | string | The class to use to group keys. Must implement org.infinispan.distribution.group.Grouper. |
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
distributed-cache-configuration
Defines a DIST_* mode cache configuration.
Name | Type | Default | Description |
---|---|---|---|
owners | int | 2 | Number of cluster-wide replicas for each cache entry. |
segments | int | 256 | Sets the number of hash space segments per cluster. The default value is 256. The value should be at least 20 * the cluster size. |
capacity-factor | double | 1.0 | Controls the proportion of entries that reside on the local node in comparison to other nodes in the cluster. You must specify a positive number as the value. The value can also be a fraction such as 1.5. |
l1-lifespan | long | Maximum lifespan in milliseconds of an entry placed in the L1 cache. By default L1 is disabled unless a positive value is configured for this attribute. If the attribute is not present, L1 is disabled. | |
l1-cleanup-interval | long | 60000 | Controls how often a cleanup task to prune L1 tracking data is run. Defaults to 10 minutes. |
consistent-hash-factory | string | The factory to use for generating the consistent hash. Must implement `org.infinispan.distribution.ch.ConsistentHashFactory`. E.g. `org.infinispan.distribution.ch.impl.SyncConsistentHashFactory` can be used to guarantee that multiple distributed caches use exactly the same consistent hash, which for performance reasons is not guaranteed by the default consistent hash factory instance used. | |
key-partitioner | string | The name of the key partitioner class. Must implement `org.infinispan.distribution.ch.KeyPartitioner`. A custom key partitioner can be used as an alternative to grouping, to guarantee that some keys are located in the same segment (and thus their primary owner is the same node). Since 8.2. |
state-transfer?
The state transfer configuration for distribution and replicated caches.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | true | If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time. |
timeout | long | 240000 | The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. Must be greater than or equal to 'remote-timeout' in the clustering configuration. |
chunk-size | integer | 512 | The number of cache entries to batch in each transfer. |
await-initial-transfer | boolean | true | If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests. |
groups?
Configures grouping of data.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | Enables or disables grouping. |
grouper*
Name | Type | Default | Description |
---|---|---|---|
class | string | The class to use to group keys. Must implement org.infinispan.distribution.group.Grouper. |
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
scattered-cache
Defines a SCATTERED_* mode cache. Deprecated since 14.0, will be removed in 16.0.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
segments | int | 256 | Number of hash space segments (per cluster). The default value is 256, and should be at least 20 * cluster size. | ||||
capacity | float | 1 | Controls the proportion of entries that will reside on the local node, compared to the other nodes in the cluster. This is just a suggestion, there is no guarantee that a node with a capacity factor of 2 will have twice as many entries as a node with a capacity factor of 1. | ||||
consistent-hash-factory | string | The factory to use for generating the consistent hash. Must implement `org.infinispan.distribution.ch.ConsistentHashFactory`. E.g. `org.infinispan.distribution.ch.impl.SyncConsistentHashFactory` can be used to guarantee that multiple distributed caches use exactly the same consistent hash, which for performance reasons is not guaranteed by the default consistent hash factory instance used. | |||||
key-partitioner | string | The name of the key partitioner class. Must implement `org.infinispan.distribution.ch.KeyPartitioner`. A custom key partitioner can be used as an alternative to grouping, to guarantee that some keys are located in the same segment (and thus their primary owner is the same node). Since 8.2. | |||||
invalidation-batch-size | integer | 128 | Threshold for sending batch invalidations. Once a node registers more updated keys, it sends a batch invalidation to all nodes requesting to remove old versions of the entries. The threshold is also used for second batch invalidation of tombstones for removed entries. | ||||
bias-acquisition |
| ON_WRITE | Specifies when is a node allowed to acquire a bias on an entry, serving further reads to the same key locally (despite not being an owner). Acquired bias allows reading data on non-owner, but slows down further writes from other nodes. | ||||
bias-lifespan | long | 300000 | Specifies the duration (in Milliseconds) that acquired bias can be held; while the reads will never be stale, tracking that information consumes memory on the primary owner. |
state-transfer?
The state transfer configuration for distribution and replicated caches.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | true | If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time. |
timeout | long | 240000 | The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. Must be greater than or equal to 'remote-timeout' in the clustering configuration. |
chunk-size | integer | 512 | The number of cache entries to batch in each transfer. |
await-initial-transfer | boolean | true | If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests. |
groups?
Configures grouping of data.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | Enables or disables grouping. |
grouper*
Name | Type | Default | Description |
---|---|---|---|
class | string | The class to use to group keys. Must implement org.infinispan.distribution.group.Grouper. |
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |
scattered-cache-configuration
Defines a SCATTERED_* mode cache configuration. Deprecated since 14.0, will be removed in 16.0.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
segments | int | 256 | Number of hash space segments (per cluster). The default value is 256, and should be at least 20 * cluster size. | ||||
capacity | float | 1 | Controls the proportion of entries that will reside on the local node, compared to the other nodes in the cluster. This is just a suggestion, there is no guarantee that a node with a capacity factor of 2 will have twice as many entries as a node with a capacity factor of 1. | ||||
consistent-hash-factory | string | The factory to use for generating the consistent hash. Must implement `org.infinispan.distribution.ch.ConsistentHashFactory`. E.g. `org.infinispan.distribution.ch.impl.SyncConsistentHashFactory` can be used to guarantee that multiple distributed caches use exactly the same consistent hash, which for performance reasons is not guaranteed by the default consistent hash factory instance used. | |||||
key-partitioner | string | The name of the key partitioner class. Must implement `org.infinispan.distribution.ch.KeyPartitioner`. A custom key partitioner can be used as an alternative to grouping, to guarantee that some keys are located in the same segment (and thus their primary owner is the same node). Since 8.2. | |||||
invalidation-batch-size | integer | 128 | Threshold for sending batch invalidations. Once a node registers more updated keys, it sends a batch invalidation to all nodes requesting to remove old versions of the entries. The threshold is also used for second batch invalidation of tombstones for removed entries. | ||||
bias-acquisition |
| ON_WRITE | Specifies when is a node allowed to acquire a bias on an entry, serving further reads to the same key locally (despite not being an owner). Acquired bias allows reading data on non-owner, but slows down further writes from other nodes. | ||||
bias-lifespan | long | 300000 | Specifies the duration (in Milliseconds) that acquired bias can be held; while the reads will never be stale, tracking that information consumes memory on the primary owner. |
state-transfer?
The state transfer configuration for distribution and replicated caches.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | true | If enabled, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time. |
timeout | long | 240000 | The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. Must be greater than or equal to 'remote-timeout' in the clustering configuration. |
chunk-size | integer | 512 | The number of cache entries to batch in each transfer. |
await-initial-transfer | boolean | true | If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests. |
groups?
Configures grouping of data.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | Enables or disables grouping. |
grouper*
Name | Type | Default | Description |
---|---|---|---|
class | string | The class to use to group keys. Must implement org.infinispan.distribution.group.Grouper. |
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
mode |
| SYNC | Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation. | ||||
remote-timeout | long | 15000 | 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. |
partition-handling?
Configures the way this cache reacts to node crashes and split brains.
Name | Type | Default | Description | ||||||
---|---|---|---|---|---|---|---|---|---|
enabled | boolean | Deprecated, use type instead. Enable/disable the partition handling functionality. Defaults to false. | |||||||
when-split |
| ALLOW_READ_WRITES | The type of actions that are possible when a split brain scenario is encountered. | ||||||
merge-policy | NONE | The entry merge policy which should be applied on partition merges. |
Name | Type | Default | Description |
---|---|---|---|
name | ID | Uniquely identifies this cache within its cache container. | |
configuration | IDREF | The name of the cache configuration which this configuration inherits from. | |
statistics | boolean | false | Determines whether or not the cache should collect statistics. Keep disabled for optimal performance. |
statistics-available | boolean | true | If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance. |
unreliable-return-values | boolean | false | Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods. |
backups?
Defines backup locations for cache data and modifies state transfer properties.
Name | Type | Default | Description |
---|---|---|---|
merge-policy | DEFAULT | Specifies the fully qualified name of a class that implements the XSiteEntryMergePolicy interface or any of the alias. Use if for ASYNC strategy backup. | |
max-cleanup-delay | positiveInteger | 30000 | Specifies the maximum delay, in milliseconds, between which tombstone cleanup tasks run. This attribute applies to the asynchronous backup strategy only. |
tombstone-map-size | positiveInteger | 512000 | Specifies the target number of tombstones to store. If the current size of the tombstone map is greater than the target size, then cleanup tasks run more frequently. If the current size of the tombstone map is less than the target size, then cleanup tasks run less frequently. This attribute applies to the asynchronous backup strategy only. |
backup*
Configures a remote site as a backup location for cache data.
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
site | string | Names the remote site to which the cache backs up data. | |||||||||
strategy |
| ASYNC | Sets the strategy for backing up to a remote site. | ||||||||
failure-policy |
| WARN | Controls how local writes to caches are handled if synchronous backup operations fail. | ||||||||
timeout | long | 15000 | Specifies timeout, in milliseconds, for synchronous and asynchronous backup operations. | ||||||||
two-phase-commit | boolean | false | Enables two-phase commits for optimistic transactional caches with the synchronous backup strategy only. | ||||||||
failure-policy-class | string | Specifies the fully qualified name of a class that implements the CustomFailurePolicy interface. Use if failure-policy="CUSTOM". |
take-offline?
Specifies the number of failures that can occur before backup locations go offline.
Name | Type | Default | Description |
---|---|---|---|
after-failures | int | 0 | Sets the number of consecutive failures that can occur for backup operations before sites go offline. Specify a negative or zero value to ignore this attribute and use minimum wait time only ("min-wait"). |
min-wait | long | 0 | Sets the minimum time to wait, in milliseconds, before sites go offline when backup operations fail. If subsequent operations are successful, the minimum wait time is reset. If you set "after-failures", sites go offline when the wait time is reached and the number of failures occur. |
state-transfer?
Modifies state transfer operations.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
chunk-size | int | 512 | Specifies how many cache entries are batched in each transfer request. | ||||
timeout | long | 1200000 | The time (in milliseconds) to wait for the backup site acknowledge the state chunk received and applied. Default value is 20 min. | ||||
max-retries | int | 30 | Sets the maximum number of retry attempts for push state failures. Specify a value of 0 (zero) to disable retry attempts. The default value is 30. | ||||
wait-time | long | 2000 | Sets the amount of time, in milliseconds, to wait between retry attempts for push state failures. You must specify a value of 1 or more. The default value is 2000. | ||||
mode |
| MANUAL | Controls whether cross-site state transfer happens manually on user action, which is the default, or automatically when backup locations come online. |
backup-for?
Defines the local cache as a backup for a remote cache with a different name.
Name | Type | Default | Description |
---|---|---|---|
remote-cache | string | Specifies the name of the remote cache that uses the local cache as a backup. | |
remote-site | string | Specifies the name of the remote site that backs up data to the local cache. |
encoding?
The cache encoding configuration.
Defines content type and encoding for keys and values of the cache.Name | Type | Default | Description |
---|---|---|---|
media-type | string | The media type for both keys and values. When present, takes precedence over the individual configurations for keys and values. |
key?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
value?
Name | Type | Default | Description |
---|---|---|---|
media-type | string |
locking?
The locking configuration of the cache.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
isolation |
| REPEATABLE_READ | Sets the cache locking isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation level. | ||||||||||
striping | boolean | false | 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. | ||||||||||
acquire-timeout | long | 10000 | Maximum time to attempt a particular lock acquisition. | ||||||||||
concurrency-level | int | 32 | Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. |
transaction?
The cache transaction configuration.
Name | Type | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mode |
| NONE | Sets the cache transaction mode to one of NONE, BATCH, NON_XA, NON_DURABLE_XA, FULL_XA. | ||||||||||
stop-timeout | long | 30000 | 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. | ||||||||||
locking |
| OPTIMISTIC | The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC. | ||||||||||
transaction-manager-lookup | string | org.infinispan.transaction.lookup.GenericTransactionManagerLookup | Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional. | ||||||||||
complete-timeout | long | 60000 | The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000. | ||||||||||
reaper-interval | long | 30000 | The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000. | ||||||||||
auto-commit | boolean | true | If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true. | ||||||||||
recovery-cache | string | __recoveryInfoCacheName__ | Sets the name of the cache where recovery related information is held. The cache's default name is "__recoveryInfoCacheName__" | ||||||||||
notifications | boolean | true | Enables or disables triggering transactional notifications on cache listeners. By default is enabled. |
expiration?
The cache expiration configuration.
Name | Type | Default | Description | ||||
---|---|---|---|---|---|---|---|
max-idle | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can remain idle. If no operations are performed on entries within the maximum idle time, the entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
lifespan | long | -1 | Specifies the maximum amount of time, in milliseconds, that cache entries can exist. After reaching their lifespan, cache entries expire across the cluster. A value of 0 or -1 disables expiration. | ||||
interval | long | 60000 | Specifies the interval, in milliseconds, between expiration runs. A value of 0 or -1 disables the expiration reaper. | ||||
touch |
| SYNC | Controls how timestamps get updated for entries in clustered caches with maximum idle expiration. The default value is SYNC. This attribute applies only to caches that use synchronous mode. Timestamps are updated asynchronously for caches that use asynchronous mode. |
store-as-binary?
Configures the cache to store data in binary format.
Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format. There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized. Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both. DEPRECATED: please use memory element insteadName | Type | Default | Description |
---|---|---|---|
keys | boolean | Specify whether keys are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. | |
values | boolean | Specify whether values are stored as binary or not. Enabled by default if the "enabled" attribute is set to true. |
persistence?
Configures the persistence layer for caches.
Name | Type | Default | Description |
---|---|---|---|
passivation | boolean | false | Enables passivation so that data is written to cache stores only if it is evicted from memory. Subsequent requests for passivated entries restore them to memory and remove them from persistent storage. If you do not enable passivation, writes to entries in memory result in writes to cache stores. |
connection-attempts | int | 10 | Sets the maximum number of attempts to start each configured `CacheWriter` or `CacheLoader`. An exception is thrown and the cache does not start if the number of connection attempts exceeds the maximum. |
connection-interval | int | 50 | Specifies the time, in milliseconds, to wait between connection attempts on startup. A negative or zero value means no wait between connection attempts. |
availability-interval | int | 1000 | Specifies the time, in milliseconds, between availability checks to determine if the PersistenceManager is available. In other words, this interval sets how often stores and loaders are polled via their `org.infinispan.persistence.spi.CacheWriter#isAvailable` or `org.infinispan.persistence.spi.CacheLoader#isAvailable` implementation. If a single store or loader is not available, an exception is thrown during cache operations. |
cluster-loader
Defines a cluster cache loader.
Name | Type | Default | Description |
---|---|---|---|
remote-timeout | long | 15000 | The timeout when performing remote calls. |
Name | Type | Default | Description |
---|---|---|---|
name | string | Unused XML attribute. | |
shared | boolean | false | Determines if a cache loader is shared between cache instances. Values are true / false (default). This property prevents duplicate writes of data to the cache loader by different cache instances. An example is where all cache instances in a cluster use the same JDBC settings for the same remote, shared database. If true, only the nodes where modifications originate write to the cache store. If false, each cache reacts to potential remote updates by storing the data to the cache store. |
preload | boolean | false | Pre-loads data into memory from the cache loader when the cache starts. Values are true / false (default). This property is useful when data in the cache loader is required immediately after startup to prevent delays with cache operations when the data is loaded lazily. This property can provide a "warm cache" on startup but it impacts performance because it affects start time. Pre-loading data is done locally, so any data loaded is stored locally in the node only. Pre-loaded data is not replicated or distributed. Likewise, data is pre-loaded only up to the maximum configured number of entries in eviction. |
property*
A cache loader property with name and value.
store
Defines a custom cache store.
Name | Type | Default | Description |
---|---|---|---|
class | string | Defines the class name of a cache store that implements either `CacheLoader`, `CacheWriter`, or both. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
file-store
Defines a filesystem-based cache store.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Deprecated since 13.0 which ignores the property. Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. Deprecated since 13.0, will be removed in 16.0. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. | |
open-files-limit | int | 1000 | Max number of data and index files opened for reading (current log file and compaction output are not included here - always uses one each). Index files will use 1/10th of list limit with a minimum of 1 and a maximum equal to the number of cache segments. |
compaction-threshold | double | 0.5 | If amount of unused space in some data file gets above this threshold, the file is compacted - entries from that file are copied to a new file and the old file is deleted. |
index?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location where the store keeps index - this does not have be persistent across restarts, and SSD storage is recommended (the index is accessed randomly). | |
segments | int | 3 | Deprecated since 15.0 which ignores the property. This value is ignored as we create an index file per cache segment instead. |
max-queue-length | int | 1000 | Max number of entry writes that are waiting to be written to the index, per index segment. |
max-node-size | int | 4096 | Max size of node (continuous block on filesystem used in index implementation), in bytes. |
min-node-size | int | 0 | If the size of node (continuous block on filesystem used in index implementation) drops below this threshold, the node will try to balance its size with some neighbour node, possibly causing join of multiple nodes. |
data?
Name | Type | Default | Description |
---|---|---|---|
path | string | A location on disk where the store writes entries. Files are written sequentially, reads are random. | |
max-file-size | int | 16777216 | Max size of single file with entries, in bytes. |
sync-writes | boolean | false | If true, the write is confirmed only after the entry is fsynced on disk. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
single-file-store
Deprecated since 13.0. Defines a filesystem-based cache store that stores its elements in a single file.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Specifies the maximum number of entries that the file store can hold. To increase the speed of lookups, Single File cache stores index keys and their locations in the file. To avoid excessive memory usage, you can configure the maximum number of entries so that entries are removed permanently from both memory and the cache store when the maximum is exceeded. However, this can lead to data loss. You should only set a maximum number of entries if data can be recomputed or retrieved from an authoritative data store. By default, the value is `-1` which means that there is no maximum number of entries. | |
path | string | Specifies a filesystem directory for data. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location. Absolute paths must be subdirectories of the global persistent location, otherwise an exception is thrown. |
Name | Type | Default | Description |
---|---|---|---|
shared | boolean | false | 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. |
transactional | boolean | false | This setting should be set to true when the underlying cache store supports transactions and it is desirable for the underlying store and the cache to remain synchronized. With this enabled any Exceptions thrown whilst writing to the underlying store will result in both the store's and cache's transactions rollingback. |
preload | boolean | false | 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. Likewise in some cases you cannot pre-load data in caches stores, such as when using shared remote stores. |
purge | boolean | false | Empties the specified cache loader at startup. Values are true / false (default). This property takes effect only if read-only is false. |
read-only | boolean | false | Prevents data from being persisted to cache stores. Values are true / false (default). If true, cache stores load entries only. Any modifications to data in the cache do not apply to cache stores. |
write-only | boolean | false | Prevents data from being loaded from cache stores. Values are true / false (default). If true, cache stores write entries only. Any retrievals of data in the cache do not read from the cache store. |
max-batch-size | int | 100 | Sets the maximum size of a batch to insert or delete from the cache store. If the value is less than one, no upper limit applies to the number of operations in a batch. |
segmented | boolean | true | Configures cache stores to store data in hash space segments, with the cache's "segments" attribute defining the number of segments. |
write-behind?
Configures cache stores as write-behind instead of write-through.
Name | Type | Default | Description |
---|---|---|---|
modification-queue-size | int | 1024 | Specifies the maximum number of entries in the asynchronous modification queue. When the queue is full, write-through mode is used until the queue can accept new entries. |
thread-pool-size | int | 1 | Specifies the number of threads to apply modifications to the cache store. |
fail-silently | boolean | false | Controls how asynchronous write operations take place when cache stores become unavailable. If "true", asynchronous write operations that fail are re-attempted with the number of times specified in the "connection-attempts" parameter. If all attempts fail, errors are ignored and write operations are not executed on the cache store. If "false", asynchronous write operations that fail are re-attempted when the underlying store becomes available. If the modification queue becomes full before the underlying store becomes available, an error is thrown on all future write operations to the store until the modification queue is flushed. The modification queue is not persisted. If the underlying store does not become available before the asynchronous store is stopped, queued modifications are lost. |
property*
Defines a cache store property with name and value.
memory?
Controls how the entries are stored in memory
Name | Type | Default | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
max-size | string | Defines the size of the data container in bytes. The default unit is B (bytes). You can optionally set one of the following units: KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), KiB (kibibytes), MiB (mebibytes), GiB (gibibytes) and TiB (tebibytes). Eviction occurs when the approximate memory usage of the data container exceeds the maximum size. | |||||||||||||||||
max-count | long | -1 | Defines the size of the data container by number of entries. Eviction occurs after the container size exceeds the maximum count. | ||||||||||||||||
when-full |
| Specifies a strategy for evicting cache entries. Eviction always takes place when you define either the max-size or the max-count (but not both) for the data container. If no strategy is defined, but max-count or max-size is configured, REMOVE is used. | |||||||||||||||||
storage |
| HEAP | Defines the type of memory that the data container uses as storage. |
query?
Defines query options for cache
Name | Type | Default | Description |
---|---|---|---|
default-max-results | integer | 100 | Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries. Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set. |
hit-count-accuracy | integer | 10000 | Limit the required accuracy of the hit count for the indexed queries to an upper-bound. Setting the hit-count-accuracy optimize the performance of queries targeting large data sets. For optimal results, set this value slightly above the expected hit count. If you do not require accurate hit counts, set it to a low value. |
indexing?
Defines indexing options for cache
Name | Type | Default | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
enabled | boolean | false | Enables and disables cache indexing. Including the indexing element in cache configuration automatically enables indexing without the need to set the value of this attribute to "true". Indexing is also automatically enabled when the "auto-config" attribute is set to a value of "true". | ||||||||
storage |
| filesystem | Specify index storage options. | ||||||||
startup-mode |
| none | Triggers an indexing process when the cache starts. | ||||||||
path | string | Specifies a filesystem path for the index when storage is 'filesystem'. The value can be a relative or absolute path. Relative paths are created relative to the configured global persistent location, or to the current working directory when global state is disabled. By default, the cache name is used as a relative path for index path. When setting a custom value, ensure that there are no conflicts between caches using the same indexed entities. | |||||||||
auto-config | boolean | false | Deprecated since 11.0, with no replacement. Whether or not to apply automatic index configuration based on cache type |
index-reader?
Controls index reading parameters.
Name | Type | Default | Description |
---|---|---|---|
refresh-interval | long | 0 | Interval, in milliseconds, to reopen the index reader. By default, the index reader is refreshed on-demand during searches, if new entries were indexed since the last refresh. Configuring with a value larger than zero will make some queries results stale, but query throughput will increase substantially, specially in write heavy scenarios. |
index-writer?
Controls index writing parameters
Name | Type | Default | Description |
---|---|---|---|
commit-interval | int | 1000 | Amount of time, in milliseconds, that index changes that are buffered in memory are flushed to the index storage and a commit is performed. Because operation is costly, small values should be avoided. The default is 1000 ms (1 second). |
ram-buffer-size | int | 32 | Maximum amount of memory that can be used for buffering added entries and deletions before they are flushed to the index storage. Large values result in faster indexing but use more memory. For faster indexing performance you should set this attribute instead of `max-buffered-entries`. When used in combination with the `max-buffered-entries` attribute, a flush occurs for whichever event happens first. |
max-buffered-entries | int | 32 | Maximum number of entries that can be buffered in-memory before they are flushed to the index storage. Large values result in faster indexing but use more memory. When used in combination with the `ram-buffer-size` attribute, a flush occurs for whichever event happens first. |
thread-pool-size | int | 1 | Number of threads that execute write operations to the index. |
queue-count | int | 1 | Number of internal queues to use for each indexed type. Each queue holds a batch of modifications that is applied to the index and queues are processed in parallel. Increasing the number of queues will lead to an increase of indexing throughput, but only if the bottleneck is CPU. For optimum results, do not set a value for `queue-count` that is larger than the value for `thread-pool-size`. |
queue-size | int | 1000 | Maximum number of elements each queue can hold. Increasing the `queue-size` value increases the amount of memory that is used during indexing operations. Setting a value that is too small can block indexing operations. |
low-level-trace | boolean | false | Enables low-level trace information for indexing operations. Enabling this attribute substantially degrades performance. You should use this low-level tracing only as a last resource for troubleshooting. |
index-merge?
Defines properties to control the merge of index segments. An index segment is not related to an Infinispan segment, but represents a section of index in the storage.
Name | Type | Default | Description |
---|---|---|---|
max-entries | int | Maximum number of entries that an index segment can have before merging. Segments with more than this number of entries are not merged. Smaller values perform better on frequently changing indexes, larger values provide better search performance if the index does not change often. | |
factor | int | Number of segments that are merged at once. With smaller values, merging happens more often, which uses more resources, but the total number of segments will be lower on average, increasing search performance. Larger values (greater than 10) are best for heavy writing scenarios. | |
min-size | int | Minimum target size of segments, in MB, for background merges. Segments smaller than this size are merged more aggressively. Setting a value that is too large might result in expensive merge operations, even though they are less frequent. | |
max-size | int | Maximum size of segments, in MB, for background merges. Segments larger than this size are never merged in the background. Settings this to a lower value helps reduce memory requirements and avoids some merging operations at the cost of optimal search speed. This attribute is ignored when forcefully merging an index and `max-forced-size` applies instead. | |
max-forced-size | int | maximum size of segments, in MB, for forced merges and overrides the `max-size` attribute. Set this to the same value as `max-size` or lower. However setting the value too low degrades search performance because documents are deleted. | |
calibrate-by-deletes | boolean | Whether the number of deleted entries in an index should be taken into account when counting the entries in the segment. Setting `false` will lead to more frequent merges caused by `max-entries`, but will more aggressively merge segments with many deleted documents, improving search performance. |
key-transformers?
Defines the Transformers used to stringify keys for indexing with Lucene
key-transformer*
Name | Type | Default | Description |
---|---|---|---|
key | string | ||
transformer | string |
indexed-entities?
Defines the set of indexed type names (fully qualified). If values of types that are not included in this set are put in the cache they will not be indexed.
indexed-entity+
Indexed entity type name. Must be either a fully qualified Java class name or a protobuf type name.
property*
Property to pass on to the indexing system
custom-interceptors?
Deprecated since 10.0, will be removed without a replacement. Configures custom interceptors to be added to the cache.
interceptor*
Deprecated since 10.0, will be removed without a replacement.
Name | Type | Default | Description |
---|---|---|---|
after | string | Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
before | string | Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts. | |
class | string | A fully qualified class name of the new custom interceptor to add to the configuration. | |
index | int | Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain. | |
position | string | Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST |
property?
security?
Configures cache-level security.
authorization?
Configures authorization for this cache.
Name | Type | Default | Description |
---|---|---|---|
enabled | boolean | false | Enables authorization checks for this cache. Defaults to true if the authorization element is present. |
roles | Sets the valid roles required to access this cache. |