schema.jboss-infinispan-core_10_0.xsd Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of infinispan-server-infinispan
Show all versions of infinispan-server-infinispan
Infinispan Server - Infinispan Subsystem
The newest version!
Enumerates the cache containers available to the registry.
Defines an embedded cache container.
Overrides the transport characteristics for this cache container.
Configures security for this cache container.
Defines the global state configuration.
Defines a thread pool used for asynchronous operations.
Defines a thread pool used for expiration.
Defines a thread pool used for asynchronous cache listener notifications.
Defines a thread pool used for interacting with the persistent store.
Defines a thread pool used for executing remote commands.
Defines a thread pool used for state transfer.
Defines a thread pool used for asynchronous transport communication.
A list of zero or more module dependencies to make available to the global ClassLoader of the cache container.
Defines a LOCAL mode cache configuration.
Defines a LOCAL mode cache.
Defines a REPL_* mode cache configuration.
Defines a REPL_* mode cache.
Defines an INVALIDATION_* mode cache configuration.
Defines an INVALIDATION_* mode cache.
Defines a DIST_* mode cache configuration.
Defines a DIST_* mode cache.
Defines counters.
Uniquely identifies this cache container.
A set of aliases by which this cache container may also be referenced.
The jndi name to which to bind this cache container.
If undefined, the cache will be bound to: java:jboss/infinispan/container/container-name
Indicates the default cache for this cache container.
Defines the executor used for asynchronous cache listener notifications. Deprecated: please use the listener-thread-pool element instead.
Defines the executor used for asynchronous cache operations. Deprecated: please use the async-operations-thread-pool element instead.
Defines the scheduled executor used for evictions. Deprecated: please use the expiration-thread-pool element instead.
Defines the executor used by the state transfer. Deprecated: please use the state-transfer-thread-pool element instead.
Defines the module whose class loader should be used when building this cache container.
Determines whether or not the cache container should collect statistics. Keep disabled for optimal performance.
Defines the channel used for this transport.
Defines the jgroups stack used by the transport. Deprecated: please use the channel attribute instead.
Defines the name for the underlying group communication cluster. Deprecated: please use the channel attribute instead.
Defines the executor used for asynchronous transport communication. Deprecated: please use the transport-thread-pool element instead.
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.
Defines the executor used for processing remote (non-total order) commands. Deprecated: please use the remote-command-thread-pool element instead.
Makes clustered operations fail with NamedCacheNotFoundException if the named cache does not exist on remote nodes.
If set to false, operations will succeed but it will be logged on the caller that the operation did not succeed on
certain nodes due to the named cache not being available. This behaviour is applicable only to replicated caches.
Defaults to false.
Defines the executor used for processing remote total order commands. Deprecated.
The minimum number of nodes that must join the cluster for the cache manager to start
The amount of time in milliseconds to wait for a cluster with sufficient nodes to form. Defaults to 60000
Configures the global authorization role to permission mapping. The presence of this element in the configuration implicitly enables authorization.
Uses the identity role mapper where principal names are converted as-is into role names.
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
Uses the cluster role mapper which stores the principal to role mappings within the cluster registry.
Uses a custom role mapper.
Class of the custom principal to role mapper
Defines a new role name and assigns permissions to it.
Defines the name of the role.
Defines the list of permissions for the role.
Defines the path where global state for this cache-container will be stored. The data stored at this location is required for graceful
shutdown and restore. This path must NOT be shared among multiple containers.
Defines the path where shared global state for this cache-container will be stored. This path may be shared across multiple containers.
Defines the path which will be used to store temporary data.
An immutable configuration storage.
A non-persistent configuration storage.
A persistent configuration storage which saves runtime configurations to the persistent-location.
A configuration storage which uses the server configuration model for configuration persistence.
Currently only implemented for standalone deployments.
Uses a custom configuration storage implementation.
Class of the custom configuration storage implementation.
Defines strong counter
Defines strong counter
Sets the number of counter’s copies to keep
cluster-wide. It must be positive and its default value is 2.
Sets the counter’s update behavior in a network
partition. Default value is AVAILABLE
The lower bound for this
strong counter
The upper bound for this
strong counter
Sets the number of concurrent
updates. Its value
must be positive and the default value is 64.
Counter name
Counter initial value. Default is 0
(zero)
Sets the counter’s behavior when the
cluster is shutdown and restarted. Default value is
VOLATILE.
Counter lower bound
Counter upper bound
The base directory in which to store the state
Defines the path where state for this cache-container will be stored.
The cross-site backup configuration.
Configures this cache as a backup for a remote cache.
The name of the remote cache that backups data here.
The name of the remote site containing the cache that backups data here.
The cache encoding configuration.
The locking configuration of the cache.
The cache transaction configuration.
The cache memory configuration.
The cache expiration configuration.
The cache persistence configuration where cache stores/loaders should be configured.
Defines a cluster cache loader. Deprecated: Please define loaders under the persistence element.
Defines a custom cache store. Deprecated: Please define stores under the persistence element.
Defines a custom cache loader. Deprecated: Please define loaders under the persistence element.
Defines a file-based cache store. Deprecated: Please define stores under the persistence element.
Defines a database cache store accessed via JDBC using string-based keys. Deprecated: Please define stores under the persistence element.
Defines a RocksDB cache store. Deprecated: Please define stores under the persistence element.
Defines a remote cache store accessed via HotRod. Deprecated: Please define stores under the persistence element.
Defines a remote cache store accessed via REST. Deprecated: Please define stores under the persistence element.
Defines indexing options for cache
Defines the Transformers used to stringify keys for indexing with Lucene
Defines the Transformer to use for the specified key class
Defines the indexed entity classes
Indexed entity class name
Property to pass on to the indexing system
The indexing mode of the cache. Defaults to NONE.
Whether or not to apply automatic index configuration based on cache type
Configures cache-level security.
Uniquely identifies this cache within its cache container.
The name of the cache configuration which this configuration inherits from.
Enables invocation batching for this cache. Defaults to false.
The jndi name to which to bind this cache.
If undefined, the cache will be bound to: java:jboss/infinispan/cache/container-name/cache-name
Defines the module whose class loader should be used when building this cache, if different from the enclosing cache container. Deprecated: This attribute is currently ignored and usages will cause a warning to be logged. It will be removed in next major version.
Determines whether or not the cache should collect statistics. Keep disabled for optimal performance.
If set to false, statistics gathering cannot be enabled during runtime. Keep disabled for optimal performance.
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.
Sets the cache locking isolation level. Defaults to READ_COMMITTED. When using REPEATABLE_READ with optimistic locking, write skew checking will be enabled.
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.
Maximum time to attempt a particular lock acquisition.
Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan.
Sets the cache transaction mode to one of NONE, NON_XA, NON_DURABLE_XA, FULL_XA.
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.
The locking mode for this cache, one of OPTIMISTIC or PESSIMISTIC.
Enables or disables triggering transactional notifications on cache listeners. By default is enabled.
Describes the content-type and encoding.
Defines encoding for keys and values of the cache.
Store keys and values as instance variables. Instances of byte[] will be wrapped to ensure equality.
Store keys and values as byte[] instances. Key and value will be serialized to binary representations.
Store keys and values as byte[] off of the Java heap. Key and value will be serialized to binary
representations and stored in native memory as to not take up Java heap. Temporary objects will be
put onto Java heap temporarily until processing is completed.
The size of the eviction cache as a long. Limits the cache to this normal by the amount of
entries in the cache.
The eviction strategy to use. This determines if eviction is even enabled or if it
has a different variant.
The size of the eviction cache as a long. If the configured type is COUNT, this will be
how many entries can be stored. If the configured type is MEMORY, this will be how much memory
in bytes can be stored.
The eviction type to use whether it is COUNT or MEMORY. COUNT will limit the cache based on
the number of entries. MEMORY will limit the cache by how much memory the entries use
The eviction strategy to use. This determines if eviction is even enabled or if it
has a different variant.
The size of the eviction cache as a long. If the configured type is COUNT, this will be
how many entries can be stored. If the configured type is MEMORY, this will be how much memory
in bytes can be stored.
The eviction type to use whether it is COUNT or MEMORY. COUNT will limit the cache based on
the number of entries. MEMORY will limit the cache by how much memory the entries use
The eviction strategy to use. This determines if eviction is even enabled or if it
has a different variant.
How many address pointers to use. For optimal performance you will want more
address pointers than you expect to have entries. This is similar to the size of an array backing
a hash map. Without collisions lookups and writes will be constant time. Each pointer will take
up 8 bytes of memory thus the default will use 8 MB of off heap memory.
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.
Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire.
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 interval to -1.
Sets the clustered cache mode, ASYNC for asynchronous operation, or SYNC for synchronous operation.
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.
The state transfer configuration for distribution and replicated caches.
The partition handling configuration for distribution and replicated caches.
The state transfer configuration for distribution and replicated caches.
The partition handling configuration for distribution and replicated caches.
Number of cluster-wide replicas for each cache entry.
Number of hash space segments (per cluster). The recommended value is 10 * cluster size. The default value is 80
Controls the proportion of entries that will reside on the local node,
compared to the other nodes in the cluster. Value must be positive. The default is 1
Maximum lifespan in milliseconds of an entry placed in the L1 cache. Defaults to 0 which means L1 is disabled.
A cache loader property with name and value.
Uniquely identifies this loader.
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.
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.
The timeout when performing remote calls.
Defines a cluster cache loader.
Defines a custom cache store.
Defines a custom cache loader.
Defines a file-based cache store.
Defines a database cache store accessed via JDBC using string-based keys.
Defines a RocksDB cache store.
Defines a remote cache store accessed via HotRod.
Defines a remote cache store accessed via REST.
Defines a soft-index file store.
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. This gives you the ability to
'overflow' to disk, similar to swapping in an operating system. 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. Defaults to false.
The maximum number of unsuccessful attempts to start each of the
configured CacheWriter/CacheLoader before an exception is thrown and
the cache fails to start.
The time, in milliseconds, to wait between subsequent connection
attempts on startup. A negative or zero value means no wait between
connection attempts.
The time, in milliseconds, between availability checks to determine
if the PersistenceManager is available. In other words, this interval
sets how often stores/loaders are polled via their
`org.infinispan.persistence.spi.CacheWriter#isAvailable`
or `org.infinispan.persistence.spi.CacheLoader#isAvailable`
implementation. If a single store/loader is not available,
an exception is thrown during cache operations.
Configures a cache store as write-behind instead of write-through.
A cache store property with name and value.
Uniquely identifies this store.
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.
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.
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.
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. Deprecated: Use the persistence element passivation attribute instead
If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled.
If true, purges this cache store when it starts up.
If true, the cache store will only be used to load entries. Any modifications made to the caches will not be applied to the store.
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.
Maximum number of entries in the asynchronous queue. When the queue is full, the store becomes write-through.
until it can accept new entries
Size of the thread pool whose threads are responsible for applying the modifications to the cache store.
The class name of the cache store implementation.
The class name of the cache loader implementation.
Sets the maximum number of in-memory mappings between keys and their position in the store.
Normally this is unlimited, but to avoid excess memory usage, an upper bound can be configured.
If this limit is exceeded, entries are removed permanently using the LRU algorithm both from
the in-memory index and the underlying file based cache store. Warning: setting this value
may cause data loss.
The base directory in which to store the cache state.
The path within "relative-to" in which to store the cache state.
If undefined, the path defaults to the cache container name.
The name of the remote cache. If undefined, the default cache will be used.
Enable/disable SO_TIMEOUT on socket connections to remote Hot Rod servers with the specified timeout, in milliseconds.
A timeout of zero is interpreted as an infinite timeout.
Enable/disable TCP_NODELAY on socket connections to remote Hot Rod servers.
Ensures that, when entries are retrieved from the remote store, they will be wrapped in a format suitable for serving via HotRod. This flag must be enabled when performing a rolling upgrade
Enables the storage of data on the remote server in "raw" format as opposed to wrapping the entries in InternalCacheEntry. This will make the remote cache interoperable between direct RemoteCacheManager clients and RemoteCacheStore stores
This property defines the protocol version that this client should use.
Max number of data files opened for reading (current log file, compaction output and index segments are not included here).
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.
Configure where and how should be the entries stored - this is the persistent location.
A location on disk where the store writes entries. Files are written sequentially, reads are random.
Max size of single file with entries, in bytes.
If true, the write is confirmed only after the entry is fsynced on disk.
Configure where and how should be the index stored.
A location where the store keeps index - this does not have to be persistent across restarts, and SSD storage is recommended (the index is accessed randomly).
Number of index segment files. Increasing this value improves throughput but requires more threads to be spawned.
Max number of entry writes that are waiting to be written to the index, per index segment.
Max size of node (continuous block on filesystem used in index implementation), in bytes.
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.
An outbound socket binding for a remote server.
Uses PLAIN authentication with the supplied credentials.
Uses DIGEST-MD5 authentication with the supplied credentials.
Uses EXTERNAL authentication, with credentials supplied by the encrypted transport client certificate.
A security realm which supplies a truststore for identifying the remote servers. If client authentication is required, then the security realm must also provide an identity keystore.
An optional SNI hostname for identifying the remote server.
Whether to append the name of the cache to the path.
The path portion of the URI of the remote REST endpoint.
The maximum allowed content length of a POST/PUT request.
The size of the socket buffer.
A connection timeout for remote cache communication.
The maximum number of connections per host.
The maximum number of total connections.
A socket timeout for remote cache communication.
Enable/disable TCP_NODELAY on socket connections to remote Hot Rod servers.
Defines the jndi name of the datasource.
Defines the JDBC dialect.
Defines the major version of the database.
Defines the minor version of the database.
Defines the table used to store cache entries.
Defines the prefix prepended to the cache name used when composing the name of the cache entry table.
Defines the column in which to store the cache key or bucket id.
Defines the column in which to store the cache entry or bucket.
Defines the column in which to store the timestamp of the cache entry or bucket.
The fetch size used when querying from this table. Used to avoid heap memory exhaustion when query is large.
The statement batch size used when modifying this table.
Determines whether database tables should be created by the store on startup.
Determines whether database tables should be dropped by the store on shutdown.
The name of the column used to store the cache key or bucket id.
The type of the column used to store the cache key or bucket id.
The name of the column used to store the cache entry or bucket.
The type of the column used to store the cache entry or bucket.
The name of the column used to store the cache entry or bucket timestamp.
The type of the column used to store the cache entry or bucket timestamp.
Defines the expiration settings for the RocksDB cache store.
Defines the data compression to use in the RocksDB store.
The base directory in which to store the cache state.
The path within "relative-to" in which to store the cache state.
If undefined, the path defaults to the cache container name.
Cache store block size.
Cache size for the cache store.
Cache store cache clear threshold.
The base directory in which to store expired cache state.
Expired entry queue size.
The type of compression to be used by RocksDB store.
No compression.
Snappy compression.
ZLib compression.
BZLib 2 compression.
LZ4 compression.
LZ4HC compression.
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.
The maximum amount of time (ms) to wait for state from neighboring caches, before throwing an exception and aborting startup.
The number of cache entries to batch in each transfer.
If enabled, this will cause the cache to wait for initial state transfer to complete before responding to requests.
Deprecated, use type instead. If enabled, the cache will enter degraded mode when it loses too many nodes.
The type of actions that are possible when a split brain scenario is encountered.
The entry merge policy which should be applied on partition merges.
If the partition does not have all owners for a given segment, both reads and writes are denied for all keys in that segment.
Allows reads for a given key if it exists in this partition, but only allows writes if this partition contains all owners of a segment.
Allow entries on each partition to diverge, with conflicts resolved during merge.
Do not attempt to resolve conflicts on merge.
Always utilise the entry located in the preferred partition.
Utilise entries from the preferred partition if non-null, otherwise utilise entries from the other partition.
If a conflict is encountered for a given key, remove all versions of that key.
Configures a specific site where this cache backups data.
Determines whether this backup is taken offline (ignored) after a certain number of tries.
Configures the properties needed to transfer the state for this site.
If > 0, the state will be transferred in batches of {@code chunkSize} cache entries.
If <= 0, the state will be transferred in all at once. Not recommended. Defaults to 512.
The time (in milliseconds) to wait for the backup site acknowledge the state chunk
received and applied. Default value is 20 min.
The maximum number of retries when a push state command fails. A value <= 0 (zero) mean that
the command will not retry. Default value is 30.
The waiting time (in milliseconds) between each retry. The value should be > 0 (zero). Default
value is 2 seconds.
Name of the remote site where this cache backups data.
The strategy used for backing up data: "SYNC" or "ASYNC". Defaults to "ASYNC"
Decides what the system would do in case of failure during backup. Defaults to "FAIL"
The timeout(millis) to be used when backing up data remotely. Defaults to 10 secs.
If 'false' then no data is backed up to this site. Defaults to 'true'.
The number of failed request operations after which this site should be taken offline. Defaults to 0 (never). A negative value would mean that the site will be taken offline after 'min-wait'.
The minimal number of millis to wait before taking this site offline, even in the case 'after-failures' is reached. If smaller or equal to 0, then only 'after-failures' is considered.
Defines the name of a property.
No locking isolation will be performed. This is only valid in local mode. In clustered mode, READ_COMMITTED will be used instead.
Unsupported. Actually configures READ_COMMITTED
Read committed is an isolation level that guarantees that any data read is committed at the moment it is read. However, depending on the outcome of other transactions, successive reads may return different results
Repeatable read is an isolation level that guarantees that any data read is committed at the moment it is read and that, within a transaction, successive reads will always return the same data.
Unsupported. Actually configures REPEATABLE_READ
Cache will not enlist within transactions.
Cache will enlist within transactions as a javax.transaction.Synchronization
Cache will enlist within transactions as a javax.transaction.xa.XAResource, without recovery.
Cache will enlist within transactions as a javax.transaction.xa.XAResource, with recovery.
All partitions are able to read and update the
counter’s value.
Only the primary partition (majority of nodes)
will be able to read and update the counter’s value. The remaining
partitions can only read its value.
The counter’s value is only available in memory.
The value will be lost when a cluster is shutdown.
The counter’s value is stored in a private and
local persistent store. The value is kept when the cluster is
shutdown and restored after a restart.
Do not index data. This is the default.
Only index changes made locally, ignoring remote changes. This is useful if indexes are shared across a cluster to prevent redundant indexing of updates.
Index all data
Only index changes on the primary owner, regardless of it's local or remote.
Never evict entries. This is the default.
Eviction will be performed manually. Equivalent internally to NONE.
Eviction will be performed automatically to ensure that "older" entries are removed to make room
for new entries.
Eviction is not performed and instead when the container is full exceptions will prevent
new entries from being written to the container. This cache must be transactional and now allow for
commit optimizations that would prevent it from performing a two phase commit.
Deprecated. Activates REMOVE policy.
Deprecated. Activates REMOVE policy.
Deprecated. Activates REMOVE policy.
Deprecated. Activates REMOVE policy.
Enables asynchronous mode.
Enables synchronous mode.
Enables Optimistic locking.
Enables Pessimistic locking.
A list of aliases.
Ignore backup failures.
Warn of backup failures.
Fail local operations when a backup failure occurs.
Evicts entries from the cache when a specified count has been set
Evicts entries from the cache when a specified memory usage has been reached. Memory usage is computed using an approximation which is tailored for the HotSpot VM. This can only be used when both key and values are stored as byte arrays. To guarantee only byte arrays are stored it is recommended to run with store as binary for both keys and values
Allows control of a cache's lifecycle (i.e. starting and stopping a
cache)
Allows reading data from a cache
Allows writing data to a cache
Allows performing task execution (e.g. distributed executors,
map/reduce) on a cache
Allows attaching listeners to a cache
Allows bulk-read operations (e.g. obtaining all the keys in a cache)
Allows bulk-write operations (e.g. clearing a cache)
Allows performing "administrative" operations on a cache
Aggregate permission which implies all of the others
Aggregate permission which implies all read permissions (READ and
BULK_READ)
Aggregate permission which implies all write permissions (WRITE and
BULK_WRITE)
Permission which means no permissions
Configures authorization for this cache.
Enables authorization checks for this cache. Defaults to true if the authorization element is present.
Sets the valid roles required to access this cache.
Minimum thread pool size for the thread pool.
Maximum thread pool size for the thread pool.
Maximum queue length for the thread pool.
Timeout in milliseconds to remove idle thread from the pool.
A module dependency specification.
The dependency module name (required),
which consists of one or more dot (.)-separated segments. Each segment must begin and end
with an alphanumeric or underscore (_), and may otherwise contain alphanumerics, underscores, and hyphens (-).
The dependency module version slot (optional).
A slot may consist of one or more alphanumerics, hyphens (-), underscores (_),
plus signs (+), asterisks (*), or dots (.).
© 2015 - 2025 Weber Informatics LLC | Privacy Policy