• Home
• org.wildfly
• wildfly-clustering-infinispan-extension
• 29.0.0.Beta1
• source code
• LocalDescriptions.properties

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jboss.as.clustering.infinispan.subsystem.LocalDescriptions.properties Maven / Gradle / Ivy

# subsystem resource
infinispan=The configuration of the infinispan subsystem.
infinispan.add=Add the infinispan subsystem.
infinispan.describe=Describe the infinispan subsystem
infinispan.remove=Remove the infinispan subsystem
# cache container resource
infinispan.cache-container=The configuration of an infinispan cache container
infinispan.cache-container.default-cache=The default infinispan cache
infinispan.cache-container.marshaller=Defines the marshalling implementation used to marshal cache entries.
infinispan.cache-container.modules=The set of modules associated with this cache container's configuration.
infinispan.cache-container.statistics-enabled=If enabled, statistics will be collected for this cache container
infinispan.cache-container.thread-pool=Defines thread pools for this cache container
infinispan.cache-container.cache=The list of caches available to this cache container
infinispan.cache-container.singleton=A set of single-instance configuration elements of the cache container.
infinispan.cache-container.aliases=The list of aliases for this cache container
infinispan.cache-container.add=Add a cache container to the infinispan subsystem
infinispan.cache-container.remove=Remove a cache container from the infinispan subsystem
# cache container read-only metrics
infinispan.cache-container.cache-manager-status=The status of the cache manager component. May return null if the cache manager is not started.
infinispan.cache-container.is-coordinator=Set to true if this node is the cluster's coordinator. May return null if the cache manager is not started.
infinispan.cache-container.coordinator-address=The logical address of the cluster's coordinator. May return null if the cache manager is not started.
infinispan.cache-container.local-address=The local address of the node. May return null if the cache manager is not started.
infinispan.cache-container.cluster-name=The name of the cluster this node belongs to. May return null if the cache manager is not started.
# cache container children
infinispan.cache-container.transport=A transport child of the cache container.
infinispan.cache-container.local-cache=A local cache child of the cache container.
infinispan.cache-container.invalidation-cache=An invalidation cache child of the cache container.
infinispan.cache-container.replicated-cache=A replicated cache child of the cache container.
infinispan.cache-container.distributed-cache=A distributed cache child of the cache container.
# thread-pool resources
infinispan.thread-pool.listener=Defines a thread pool used for asynchronous cache listener notifications.
infinispan.thread-pool.expiration=Defines a thread pool used for for evictions.
infinispan.thread-pool.blocking=Defines a thread pool used for for blocking operations.
infinispan.thread-pool.non-blocking=Defines a thread pool used for for non-blocking operations.
infinispan.thread-pool.add=Adds a thread pool executor.
infinispan.thread-pool.remove=Removes a thread pool executor.
infinispan.thread-pool.min-threads=The core thread pool size which is smaller than the maximum pool size. If undefined, the core thread pool size is the same as the maximum thread pool size.
infinispan.thread-pool.max-threads=The maximum thread pool size.
infinispan.thread-pool.queue-length=The queue length.
infinispan.thread-pool.keepalive-time=Used to specify the amount of milliseconds that pool threads should be kept running when idle; if not specified, threads will run until the executor is shut down.
# transport resource
infinispan.transport.jgroups=The description of the transport used by this cache container
infinispan.transport.jgroups.add=Add the transport to the cache container
infinispan.transport.jgroups.remove=Remove the transport from the cache container
infinispan.transport.jgroups.channel=The channel of this cache container's transport.
infinispan.transport.jgroups.lock-timeout=The timeout for locks for the transport
infinispan.transport.jgroups.machine=A machine identifier for the transport
infinispan.transport.jgroups.rack=A rack identifier for the transport
infinispan.transport.jgroups.site=A site identifier for the transport
infinispan.transport.none=A local-only transport used by this cache-container
infinispan.transport.none.add=Adds a local transport to this cache container
infinispan.transport.none.remove=Removes a local transport from this cache container
# (hierarchical) cache resource
infinispan.cache.statistics-enabled=If enabled, statistics will be collected for this cache
infinispan.cache.modules=The set of modules associated with this cache's configuration.
infinispan.cache.remove=Remove a cache from this container.
# cache read-only metrics
infinispan.cache.cache-status=The status of the cache component.
infinispan.cache.average-read-time=Average time (in ms) for cache reads. Includes hits and misses.
infinispan.cache.average-remove-time=Average time (in ms) for cache removes.
infinispan.cache.average-write-time=Average time (in ms) for cache writes.
infinispan.cache.elapsed-time=Time (in secs) since cache started.
infinispan.cache.hit-ratio=The hit/miss ratio for the cache (hits/hits+misses).
infinispan.cache.hits=The number of cache attribute hits.
infinispan.cache.misses=The number of cache attribute misses.
infinispan.cache.number-of-entries=The number of entries in the cache including passivated entries.
infinispan.cache.number-of-entries-in-memory=The number of entries in the cache excluding passivated entries.
infinispan.cache.read-write-ratio=The read/write ratio of the cache ((hits+misses)/stores).
infinispan.cache.remove-hits=The number of cache attribute remove hits.
infinispan.cache.remove-misses=The number of cache attribute remove misses.
infinispan.cache.stores=The number of cache attribute put operations.
infinispan.cache.time-since-reset=Time (in secs) since cache statistics were reset.
infinispan.cache.time-since-start=Time (in secs) since cache was started.
infinispan.cache.writes=The number of cache attribute put operations.
infinispan.cache.invalidations=The number of cache invalidations.
infinispan.cache.passivations=The number of cache node passivations (passivating a node from memory to a cache store).
infinispan.cache.activations=The number of cache node activations (bringing a node into memory from a cache store).
#
infinispan.cache.remote-timeout=In SYNC mode, the timeout (in ms) used to wait for an acknowledgment when making a remote call, after which the call is aborted and an exception is thrown.
# metrics
infinispan.cache.average-replication-time=The average time taken to replicate data around the cluster.
infinispan.cache.replication-count=The number of times data was replicated around the cluster.
infinispan.cache.replication-failures=The number of data replication failures.
infinispan.cache.success-ratio=The data replication success ratio (successes/successes+failures).
# operations
infinispan.cache.reset-statistics=Reset the statistics for this cache.

#child resource aliases
infinispan.cache.memory=Alias to the eviction configuration component
infinispan.cache.eviction=Alias to the memory=object resource
infinispan.cache.expiration=Alias to the expiration configuration component
infinispan.cache.locking=Alias to the locking configuration component
infinispan.cache.state-transfer=Alias to the state-transfer configuration component
infinispan.cache.transaction=Alias to the transaction configuration component
infinispan.cache.file-store=Alias to the file store configuration component
infinispan.cache.remote-store=Alias to the file store configuration component
infinispan.cache.write-behind=Alias to the write behind configuration component
infinispan.cache.backup=Alias to the backup child of the backups configuration
infinispan.cache.segments=Controls the number of hash space segments which is the granularity for key distribution in the cluster. Value must be strictly positive.
infinispan.cache.evictions=The number of cache eviction operations.

infinispan.local-cache=A local cache configuration
infinispan.local-cache.add=Add a local cache to this cache container
infinispan.local-cache.remove=Remove a local cache from this cache container

infinispan.invalidation-cache=An invalidation cache
infinispan.invalidation-cache.add=Add an invalidation cache to this cache container
infinispan.invalidation-cache.remove=Remove an invalidation cache from this cache container

infinispan.replicated-cache=A replicated cache configuration
infinispan.replicated-cache.add=Add a replicated cache to this cache container
infinispan.replicated-cache.remove=Remove a replicated cache from this cache container

infinispan.component.partition-handling=The partition handling configuration for distributed and replicated caches.
infinispan.component.partition-handling.add=Add a partition handling configuration.
infinispan.component.partition-handling.remove=Remove a partition handling configuration.
infinispan.component.partition-handling.when-split=Defines the availability of cache entries after a network partition is detected.
infinispan.component.partition-handling.merge-policy=Defines the policy for resolving cache entry conflicts when merging partitions.
infinispan.component.partition-handling.enabled=If enabled, the cache will enter degraded mode upon detecting a network partition that threatens the integrity of the cache.
infinispan.component.partition-handling.enabled.deprecated=Deprecated. Partition handling behavior is defined by the when-split attribute.
infinispan.component.partition-handling.availability=Indicates the current availability of the cache.
infinispan.component.partition-handling.force-available=Forces a cache with degraded availability to become available.

infinispan.component.state-transfer=The state transfer configuration for distributed and replicated caches.
infinispan.component.state-transfer.add=Add a state transfer configuration.
infinispan.component.state-transfer.remove=Remove a state transfer configuration.
infinispan.component.state-transfer.timeout=The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup. If timeout is 0, state transfer is performed asynchronously, and the cache will be immediately available.
infinispan.component.state-transfer.chunk-size=The maximum number of cache entries in a batch of transferred state.

infinispan.distributed-cache=A distributed cache configuration.
infinispan.distributed-cache.add=Add a distributed cache to this cache container
infinispan.distributed-cache.remove=Remove a distributed cache from this cache container
infinispan.distributed-cache.owners=Number of cluster-wide replicas for each cache entry.
infinispan.distributed-cache.l1-lifespan=Maximum lifespan of an entry placed in the L1 cache. This element configures the L1 cache behavior in 'distributed' caches instances. In any other cache modes, this element is ignored.
infinispan.distributed-cache.capacity-factor=Controls the proportion of entries that will reside on the local node, compared to the other nodes in the cluster.

infinispan.scattered-cache=A scattered cache configuration.
infinispan.scattered-cache.deprecated=Deprecated. Use distributed-cache with owners=2 instead.
infinispan.scattered-cache.add=Add a scattered cache to this cache container
infinispan.scattered-cache.remove=Remove a scattered cache from this cache container
infinispan.scattered-cache.bias-lifespan=When greater than zero, specifies the duration (in ms) that a cache entry will be cached on a non-owner following a write operation.
infinispan.scattered-cache.invalidation-batch-size=The threshold after which batched invalidations are sent.

infinispan.cache.store=A persistent store for a cache.
infinispan.cache.component=A configuration component of a cache.

infinispan.component.locking=The locking configuration of the cache.
infinispan.component.locking.add=Adds a locking configuration element to the cache.
infinispan.component.locking.remove=Removes a locking configuration element from the cache.
infinispan.component.locking.isolation=Sets the cache locking isolation level.
infinispan.component.locking.striping=If true, a pool of shared locks is maintained for all entries that need to be locked. Otherwise, a lock is created per entry in the cache. Lock striping helps control memory footprint but may reduce concurrency in the system.
infinispan.component.locking.acquire-timeout=Maximum time to attempt a particular lock acquisition.
infinispan.component.locking.concurrency-level=Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan.
infinispan.component.locking.concurrency-level.deprecated=Deprecated. This attribute will be ignored.
# metrics
infinispan.component.locking.current-concurrency-level=The estimated number of concurrently updating threads which this cache can support.
infinispan.component.locking.current-concurrency-level.deprecated=Deprecated. Returns the concurrency-level with which the cache was configured.
infinispan.component.locking.number-of-locks-available=The number of locks available to this cache.
infinispan.component.locking.number-of-locks-held=The number of locks currently in use by this cache.

infinispan.component.transaction=The cache transaction configuration.
infinispan.component.transaction.add=Adds a transaction configuration element to the cache.
infinispan.component.transaction.complete-timeout=The duration (in ms) after which idle transactions are removed.
infinispan.component.transaction.remove=Removes a transaction configuration element from the cache.
infinispan.component.transaction.mode=Sets the cache transaction mode to one of NONE, NON_XA, NON_DURABLE_XA, FULL_XA.
infinispan.component.transaction.stop-timeout=If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing remote and local transactions to finish. The amount of time to wait for is defined by the cache stop timeout.
infinispan.component.transaction.locking=The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC.
infinispan.component.transaction.timeout=The duration (in ms) after which idle transactions are rolled back.
# metrics
infinispan.component.transaction.commits=The number of transaction commits.
infinispan.component.transaction.prepares=The number of transaction prepares.
infinispan.component.transaction.rollbacks=The number of transaction rollbacks.
#
infinispan.memory.heap=On-heap object-based memory configuration.
infinispan.memory.off-heap=Off-heap memory configuration.
infinispan.memory.add=Adds a memory configuration element to the cache.
infinispan.memory.remove=Removes an eviction configuration element from the cache.
infinispan.memory.size=Eviction threshold, as defined by the size unit.
infinispan.memory.size-unit=The unit of the eviction threshold.
infinispan.memory.object.size=Triggers eviction of the least recently used entries when the number of cache entries exceeds this threshold.

# metrics
infinispan.memory.evictions=The number of cache eviction operations.
#
infinispan.component.expiration=The cache expiration configuration.
infinispan.component.expiration.add=Adds an expiration configuration element to the cache.
infinispan.component.expiration.remove=Removes an expiration configuration element from the cache.
infinispan.component.expiration.max-idle=Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
infinispan.component.expiration.lifespan=Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire.
infinispan.component.expiration.interval=Interval (in milliseconds) between subsequent runs to purge expired entries from memory and any cache stores. If you wish to disable the periodic eviction process altogether, set wakeupInterval to -1.

infinispan.store.custom=The cache store configuration.
infinispan.store.custom.add=Adds a basic cache store configuration element to the cache.
infinispan.store.custom.remove=Removes a cache store configuration element from the cache.

infinispan.store.shared=This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store.
infinispan.store.preload=If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
infinispan.store.passivation=If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
infinispan.store.fetch-state=If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
infinispan.store.fetch-state.deprecated=Deprecated. Persistent state will always be fetched if store is not shared.
infinispan.store.purge=If true, purges this cache store when it starts up.
infinispan.store.max-batch-size=The maximum size of a batch to be inserted/deleted from the store. If the value is less than one, then no upper limit is placed on the number of operations in a batch.
infinispan.store.segmented=Indicates whether or not this cache store should be segment aware.
infinispan.store.properties=A list of cache store properties.
infinispan.store.write=The write behavior of the cache store.

infinispan.store.custom.class=The custom store implementation class to use for this cache store.

# metrics
infinispan.store.cache-loader-loads=The number of cache loader node loads.
infinispan.store.cache-loader-misses=The number of cache loader node misses.

infinispan.write.behind=Configures a cache store as write-behind instead of write-through.
infinispan.write.behind.add=Adds a write-behind configuration element to the store.
infinispan.write.behind.remove=Removes a write-behind configuration element from the store.
infinispan.write.behind.modification-queue-size=Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through until it can accept new entries.

infinispan.write.through=Configures a cache store as write-through.
infinispan.write.through.add=Add a write-through configuration to the store.
infinispan.write.through.remove=Remove a write-through configuration to the store.

infinispan.store.none=A store-less configuration.
infinispan.store.none.add=Adds a store-less configuration to this cache
infinispan.store.none.remove=Removes a store-less configuration from this cache

infinispan.store.file=The cache file store configuration.
infinispan.store.file.add=Adds a file cache store configuration element to the cache.
infinispan.store.file.remove=Removes a cache file store configuration element from the cache.
infinispan.store.file.relative-to=The system path to which the specified path is relative.
infinispan.store.file.relative-to.deprecated=Deprecated. Uses the persistence location of the associated cache container.
infinispan.store.file.path=The system path under which this cache store will persist its entries.
infinispan.store.file.path.deprecated=Deprecated. Uses the persistence location of the associated cache container.

infinispan.store.jdbc=The cache JDBC store configuration.
infinispan.store.jdbc.add=Adds a JDBC cache store configuration element to the cache.
infinispan.store.jdbc.remove=Removes a JDBC cache store configuration element to the cache.
infinispan.store.jdbc.data-source=References the data source used to connect to this store.
infinispan.store.jdbc.dialect=The dialect of this datastore.
infinispan.store.jdbc.table=Defines a table used to store persistent cache data.

infinispan.table.string=Defines a table used to store cache entries whose keys can be expressed as strings.
infinispan.table.string.add=Adds a table used to store cache entries whose keys can be expressed as strings.
infinispan.table.string.remove=Removes a table used to store cache entries whose keys can be expressed as strings.

infinispan.table.prefix=The prefix for the database table name.
infinispan.table.batch-size=For DB inserts, the batch size determines how many inserts are batched together.
infinispan.table.batch-size.deprecated=Deprecated. Use max-batch-size instead.
infinispan.table.fetch-size=For DB queries, the fetch size will be used to set the fetch size on ResultSets.
infinispan.table.create-on-start=Indicates whether the store should create this database table when the cache starts.
infinispan.table.drop-on-stop=Indicates whether the store should drop this database table when the cache stops.
infinispan.table.id-column=A database column to hold cache entry ids.
infinispan.table.id-column.column.name=The name of the database column.
infinispan.table.id-column.column.type=The type of the database column.
infinispan.table.data-column=A database column to hold cache entry data.
infinispan.table.data-column.column.name=The name of the database column.
infinispan.table.data-column.column.type=The type of the database column.
infinispan.table.segment-column=A database column to hold cache entry segment.
infinispan.table.segment-column.column.name=The name of the database column.
infinispan.table.segment-column.column.type=The type of the database column.
infinispan.table.timestamp-column=A database column to hold cache entry timestamps.
infinispan.table.timestamp-column.column.name=The name of the database column.
infinispan.table.timestamp-column.column.type=The type of the database column.

# /subsystem=infinispan/cache-container=X/cache=Y/store=remote
infinispan.store.remote=The cache remote store configuration.
infinispan.store.remote.deprecated=Use HotRod store instead.
infinispan.store.remote.cache=The name of the remote cache to use for this remote store.
infinispan.store.remote.tcp-no-delay=A TCP_NODELAY value for remote cache communication.
infinispan.store.remote.socket-timeout=A socket timeout for remote cache communication.
infinispan.store.remote.remote-servers=A list of remote servers for this cache store.
infinispan.store.remote.remote.servers.remote-server=A remote server, defined by its outbound socket binding.
infinispan.store.remote.remote-servers.remote-server.outbound-socket-binding=An outbound socket binding for a remote server.
infinispan.store.remote.add=Adds a remote cache store configuration element to the cache.
infinispan.store.remote.remove=Removes a cache remote store configuration element from the cache.

# /subsystem=infinispan/cache-container=X/cache=Y/store=hotrod
infinispan.store.hotrod=HotRod-based store using Infinispan Server instance to store data.
infinispan.store.hotrod.add=Adds HotRod store.
infinispan.store.hotrod.remove=Removes HotRod store.
infinispan.store.hotrod.cache-configuration=Name of the cache configuration template defined in Infinispan Server to create caches from.
infinispan.store.hotrod.remote-cache-container=Reference to a container-managed remote-cache-container.

infinispan.backup=A backup site to which to replicate this cache.
infinispan.backup.add=Adds a backup site to this cache.
infinispan.backup.remove=Removes a backup site from this cache.
infinispan.backup.strategy=The backup strategy for this cache
infinispan.backup.failure-policy=The policy to follow when connectivity to the backup site fails.
infinispan.backup.enabled=Indicates whether or not this backup site is enabled.
infinispan.backup.enabled.deprecated=Deprecated. Ignored if specified.
infinispan.backup.timeout=The timeout for replicating to the backup site.
infinispan.backup.after-failures=Indicates the number of failures after which this backup site should go offline.
infinispan.backup.min-wait=Indicates the minimum time (in milliseconds) to wait after the max number of failures is reached, after which this backup site should go offline.
# cross-site backup operations
infinispan.backup.site-status=Displays the current status of the backup site.
infinispan.backup.bring-site-online=Re-enables a previously disabled backup site.
infinispan.backup.take-site-offline=Disables backup to a remote site.

infinispan.component.backups=The remote backups for this cache.
infinispan.component.backups.add=Adds remote backup support to this cache.
infinispan.component.backups.remove=Removes remote backup support from this cache.
infinispan.component.backups.backup=A remote backup.

# /subsystem=infinispan/remote-cache-container=*
infinispan.remote-cache-container=The configuration of a remote Infinispan cache container.
infinispan.remote-cache-container.add=Add a remote cache container to the infinispan subsystem.
infinispan.remote-cache-container.remove=Remove a cache container from the infinispan subsystem.
infinispan.remote-cache-container.component=A configuration component of a remote cache container.
infinispan.remote-cache-container.thread-pool=Defines thread pools for this remote cache container.
infinispan.remote-cache-container.near-cache=Configures near caching.
infinispan.remote-cache-container.connection-timeout=Defines the maximum socket connect timeout before giving up connecting to the server.
infinispan.remote-cache-container.default-remote-cluster=Required default remote server cluster.
infinispan.remote-cache-container.key-size-estimate=This hint allows sizing of byte buffers when serializing and deserializing keys, to minimize array resizing.
infinispan.remote-cache-container.key-size-estimate.deprecated=Deprecated. This attribute will be ignored.
infinispan.remote-cache-container.max-retries=Sets the maximum number of retries for each request. A valid value should be greater or equals than 0. Zero means no retry will made in case of a network failure.
infinispan.remote-cache-container.marshaller=Defines the marshalling implementation used to marshal cache entries.
infinispan.remote-cache-container.module=The module associated with this remote cache container's configuration.
infinispan.remote-cache-container.module.deprecated=Deprecated. Superseded by the modules attribute.
infinispan.remote-cache-container.modules=The set of modules associated with this remote cache container's configuration.
infinispan.remote-cache-container.name=Uniquely identifies this remote cache container.
infinispan.remote-cache-container.properties=A list of remote cache container properties.
infinispan.remote-cache-container.protocol-version=This property defines the protocol version that this client should use.
infinispan.remote-cache-container.socket-timeout=Enable or disable SO_TIMEOUT on socket connections to remote Hot Rod servers with the specified timeout, in milliseconds. A timeout of 0 is interpreted as an infinite timeout.
infinispan.remote-cache-container.statistics-enabled=Enables statistics gathering for this remote cache.
infinispan.remote-cache-container.tcp-no-delay=Enable or disable TCP_NODELAY on socket connections to remote Hot Rod servers.
infinispan.remote-cache-container.tcp-keep-alive=Configures TCP Keepalive on the TCP stack.
infinispan.remote-cache-container.value-size-estimate=This hint allows sizing of byte buffers when serializing and deserializing values, to minimize array resizing.
infinispan.remote-cache-container.value-size-estimate.deprecated=Deprecated. This attribute will be ignored.
infinispan.remote-cache-container.active-connections=The number of active connections to the Infinispan server.
infinispan.remote-cache-container.connections=The total number of connections to the Infinispan server.
infinispan.remote-cache-container.idle-connections=The number of idle connections to the Infinispan server.
infinispan.remote-cache-container.transaction-timeout=The duration (in ms) after which idle transactions are rolled back.
infinispan.remote-cache-container.remote-cache=A remote cache runtime resource

infinispan.remote-cache.average-read-time=The average read time, in milliseconds, for this remote cache.
infinispan.remote-cache.average-remove-time=The average remove time, in milliseconds, for this remote cache.
infinispan.remote-cache.average-write-time=The average write time, in milliseconds, to this remote cache.
infinispan.remote-cache.near-cache-hits=The number of near-cache hits for this remote cache.
infinispan.remote-cache.near-cache-invalidations=The number of near-cache invalidations for this remote cache.
infinispan.remote-cache.near-cache-misses=The number of near-cache misses for this remote cache.
infinispan.remote-cache.near-cache-size=The number of entries in the near-cache for this remote cache.
infinispan.remote-cache.hits=The number of hits to this remote cache, excluding hits from the near-cache.
infinispan.remote-cache.misses=The number of misses to this remote cache.
infinispan.remote-cache.removes=The number of removes to this remote cache.
infinispan.remote-cache.writes=The number of writes to this remote cache.
infinispan.remote-cache.reset-statistics=Resets the statistics for this remote cache.
infinispan.remote-cache.time-since-reset=The number of seconds since statistics were reset on this remote cache.

# /subsystem=infinispan/remote-cache-container=X/thread-pool=async
infinispan.thread-pool.async=Defines a thread pool used for asynchronous operations.
infinispan.thread-pool.async.add=Adds thread pool configuration used for asynchronous operations.
infinispan.thread-pool.async.remove=Removes thread pool configuration used for asynchronous operations.

# /subsystem=infinispan/remote-cache-container=*/component=connection-pool
infinispan.component.connection-pool=Configuration of the connection pool.
infinispan.component.connection-pool.add=Adds configuration of the connection pool.
infinispan.component.connection-pool.remove=Removes configuration of the connection pool.
infinispan.component.connection-pool.exhausted-action=Specifies what happens when asking for a connection from a server's pool, and that pool is exhausted.
infinispan.component.connection-pool.max-active=Controls the maximum number of connections per server that are allocated (checked out to client threads, or idle in the pool) at one time. When non-positive, there is no limit to the number of connections per server. When maxActive is reached, the connection pool for that server is said to be exhausted. Value -1 means no limit.
infinispan.component.connection-pool.max-wait=The amount of time in milliseconds to wait for a connection to become available when the exhausted action is ExhaustedAction.WAIT, after which a java.util.NoSuchElementException will be thrown. If a negative value is supplied, the pool will block indefinitely.
infinispan.component.connection-pool.min-evictable-idle-time=Specifies the minimum amount of time that an connection may sit idle in the pool before it is eligible for eviction due to idle time. When non-positive, no connection will be dropped from the pool due to idle time alone. This setting has no effect unless timeBetweenEvictionRunsMillis > 0.
infinispan.component.connection-pool.min-idle=Sets a target value for the minimum number of idle connections (per server) that should always be available. If this parameter is set to a positive number and timeBetweenEvictionRunsMillis > 0, each time the idle connection eviction thread runs, it will try to create enough idle instances so that there will be minIdle idle instances available for each server.

# /subsystem=infinispan/remote-cache-container=*/component=remote-clusters/remote-cluster=*
infinispan.remote-cluster=Configuration of a remote cluster.
infinispan.remote-cluster.add=Adds a remote cluster configuration requiring socket-bindings configuration.
infinispan.remote-cluster.remove=Removes this remote cluster configuration.
infinispan.remote-cluster.socket-bindings=List of outbound-socket-bindings of Hot Rod servers to connect to.
infinispan.remote-cluster.switch-cluster=Switch the cluster to which this HotRod client should communicate. Primary used to failback to the local site in the event of a site failover.

# /subsystem=infinispan/remote-cache-container=*/component=security
infinispan.component.security=Security configuration.
infinispan.component.security.add=Adds security configuration.
infinispan.component.security.remove=Removes security configuration.
infinispan.component.security.ssl-context=Reference to the Elytron-managed SSLContext to be used for connecting to the remote cluster.