org.infinispan.client.hotrod
Class RemoteCacheManager

java.lang.Object
  org.infinispan.client.hotrod.RemoteCacheManager

All Implemented Interfaces:

Lifecycle, CacheContainer

public class RemoteCacheManager
extends Object
implements CacheContainer

Factory for RemoteCaches.

Lifecycle:

In order to be able to use an RemoteCache, the RemoteCacheManager must be started first: beside other things, this instantiates connections to Hot Rod server(s). Starting the RemoteCacheManager can be done either at creation by passing start==true to constructor or by using a constructor that does that for you (see C-tor documentation); or after construction by calling start().

This is an "expensive" object, as it manages a set of persistent TCP connections to the Hot Rod servers. It is recommended to only have one instance of this per JVM, and to cache it between calls to the server (i.e. remoteCache operations).

stop() needs to be called explicitly in order to release all the resources (e.g. threads, TCP connections).

Configuration:

The cache manager is configured through a Properties object passed to the constructor (there are also "simplified" constructors that rely on default values).

Below is the list of supported configuration elements:

• infinispan.client.hotrod.request_balancing_strategy, default = org.infinispan.client.hotrod.impl.transport.tcp.RoundRobinBalancingStrategy. For replicated (vs distributed) Hot Rod server clusters, the client balances requests to the servers according to this strategy.
• infinispan.client.hotrod.server_list, default = 127.0.0.1:11311. This is the initial list of Hot Rod servers to connect to, specified in the following format: host1:port1;host2:port2... At least one host:port must be specified.
• infinispan.client.hotrod.force_return_values, default = false. Whether or not to implicitly Flag.FORCE_RETURN_VALUE for all calls.
• infinispan.client.hotrod.tcp_no_delay, default = true. Affects TCP NODELAY on the TCP stack.
• infinispan.client.hotrod.ping_on_startup, default = true. If true, a ping request is sent to a back end server in order to fetch cluster's topology.
• infinispan.client.hotrod.transport_factory, default = org.infinispan.client.hotrod.impl.transport.tcp.TcpTransportFactory - controls which transport to use. Currently only the TcpTransport is supported.
• infinispan.client.hotrod.marshaller, default = org.infinispan.marshall.jboss.GenericJBossMarshaller. Allows you to specify a custom Marshaller implementation to serialize and deserialize user objects.
• infinispan.client.hotrod.async_executor_factory, default = org.infinispan.client.hotrod.impl.async.DefaultAsyncExecutorFactory. Allows you to specify a custom asynchroous executor for async calls.
• infinispan.client.hotrod.default_executor_factory.pool_size, default = 10. If the default executor is used, this configures the number of threads to initialize the executor with.
• infinispan.client.hotrod.default_executor_factory.queue_size, default = 100000. If the default executor is used, this configures the queue size to initialize the executor with.
• infinispan.client.hotrod.hash_function_impl.1, default = org.infinispan.client.hotrod.impl.consistenthash.ConsistentHashV1. This specifies the version of the hash function and consistent hash algorithm in use, and is closely tied with the HotRod server version used.
• infinispan.client.hotrod.key_size_estimate, default = 64. This hint allows sizing of byte buffers when serializing and deserializing keys, to minimize array resizing.
• infinispan.client.hotrod.value_size_estimate, default = 512. This hint allows sizing of byte buffers when serializing and deserializing values, to minimize array resizing.

The following properties are related to connection pooling:

• maxActive - 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. The default setting for this parameter is -1, i.e. there is no limit.
• maxTotal - sets a global limit on the number persistent connections that can be in circulation within the combined set of servers. When non-positive, there is no limit to the total number of persistent connections in circulation. When maxTotal is exceeded, all connections pools are exhausted. The default setting for this parameter is -1 (no limit).
• maxIdle - controls the maximum number of idle persistent connections, per server, at any time. When negative, there is no limit to the number of connections that may be idle per server. The default setting for this parameter is -1.
• whenExhaustedAction - specifies what happens when asking for a connection from a server's pool, and that pool is exhausted. Possible values:
  • 0 - an exception will be thrown to the calling user
  • 1 - the caller will block (invoke waits until a new or idle connections is available.
  • 2 - a new persistent connection will be created and returned (essentially making maxActive meaningless.)
  The default whenExhaustedAction setting is 1.
• Optionally, one may configure the pool to examine and possibly evict connections as they sit idle in the pool and to ensure that a minimum number of idle connections is maintained for each server. This is performed by an "idle connection eviction" thread, which runs asynchronously. The idle object evictor does not lock the pool throughout its execution. The idle connection eviction thread may be configured using the following attributes:
  • timeBetweenEvictionRunsMillis - indicates how long the eviction thread should sleep before "runs" of examining idle connections. When non-positive, no eviction thread will be launched. The default setting for this parameter is 2 minutes
  • minEvictableIdleTimeMillis - 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. The default setting for this parameter is 1800000(30 minutes).
  • testWhileIdle - indicates whether or not idle connections should be validated by sending an TCP packet to the server, during idle connection eviction runs. Connections that fail to validate will be dropped from the pool. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is true.
  • minIdle - 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. The default setting for this parameter is 1.

Since:

4.1

Author:

Mircea.Markus@jboss.com

Field Summary

static String

HOTROD_CLIENT_PROPERTIES

Fields inherited from interface org.infinispan.manager.CacheContainer

DEFAULT_CACHE_NAME

Constructor Summary

RemoteCacheManager()
Same as RemoteCacheManager(boolean) and it also starts the cache.

RemoteCacheManager(boolean start)
Same as RemoteCacheManager(java.util.Properties), but it will try to lookup the config properties in the classpath, in a file named hotrod-client.properties.

RemoteCacheManager(Marshaller marshaller, Properties props)
Same as RemoteCacheManager(Marshaller, java.util.Properties, boolean) with start = true.

RemoteCacheManager(Marshaller marshaller, Properties props, boolean start)
Builds a remote cache manager that relies on the provided Marshaller for marshalling keys and values to be send over to the remote Infinispan cluster.

RemoteCacheManager(Properties props)
Same as RemoteCacheManager(java.util.Properties, boolean), and it also starts the cache (start==true).

RemoteCacheManager(Properties props, boolean start)
Build a cache manager based on supplied properties.

RemoteCacheManager(String servers)
Same as RemoteCacheManager(String, boolean), with start=true.

RemoteCacheManager(String servers, boolean start)
The given string should have the following structure: "host1:port2;host:port2...".

RemoteCacheManager(String host, int port)
Same as RemoteCacheManager(String, int, boolean) with start=true.

RemoteCacheManager(String host, int port, boolean start)
Creates a remote cache manager aware of the Hot Rod server listening at host:port.

RemoteCacheManager(URL config)
Same as RemoteCacheManager(java.net.URL) and it also starts the cache (start==true).

RemoteCacheManager(URL config, boolean start)
Same as RemoteCacheManager(java.util.Properties), but it will try to lookup the config properties in supplied URL.

Method Summary

<K,V> RemoteCache<K,V>	getCache() Retrieves the default cache associated with this cache container.
<K,V> RemoteCache<K,V>	getCache(boolean forceReturnValue)
<K,V> RemoteCache<K,V>	getCache(String cacheName) Retrieves a named cache from the system.
<K,V> RemoteCache<K,V>	getCache(String cacheName, boolean forceReturnValue)
boolean	isStarted()
void	start()
void	stop()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

HOTROD_CLIENT_PROPERTIES

public static final String HOTROD_CLIENT_PROPERTIES

See Also:

Constant Field Values

Constructor Detail

RemoteCacheManager

public RemoteCacheManager(Marshaller marshaller,
                          Properties props,
                          boolean start)

Builds a remote cache manager that relies on the provided Marshaller for marshalling keys and values to be send over to the remote Infinispan cluster.

Parameters:

marshaller - marshaller implementation to be used

props - other properties

start - weather or not to start the manager on return from the constructor.

RemoteCacheManager

public RemoteCacheManager(Marshaller marshaller,
                          Properties props)

Same as RemoteCacheManager(Marshaller, java.util.Properties, boolean) with start = true.

RemoteCacheManager

public RemoteCacheManager(Properties props,
                          boolean start)

Build a cache manager based on supplied properties.

RemoteCacheManager

public RemoteCacheManager(Properties props)

Same as RemoteCacheManager(java.util.Properties, boolean), and it also starts the cache (start==true).

RemoteCacheManager

public RemoteCacheManager(boolean start)

Same as RemoteCacheManager(java.util.Properties), but it will try to lookup the config properties in the classpath, in a file named hotrod-client.properties. If no properties can be found in the classpath, the server tries to connect to "127.0.0.1:11311" in start.

Parameters:

start - weather or not to start the RemoteCacheManager

Throws:

HotRodClientException - if such a file cannot be found in the classpath

RemoteCacheManager

public RemoteCacheManager()

Same as RemoteCacheManager(boolean) and it also starts the cache.

RemoteCacheManager

public RemoteCacheManager(String host,
                          int port,
                          boolean start)

Creates a remote cache manager aware of the Hot Rod server listening at host:port.

Parameters:

start - weather or not to start the RemoteCacheManager.

RemoteCacheManager

public RemoteCacheManager(String host,
                          int port)

Same as RemoteCacheManager(String, int, boolean) with start=true.

RemoteCacheManager

public RemoteCacheManager(String servers,
                          boolean start)

The given string should have the following structure: "host1:port2;host:port2...". Every host:port defines a server.

RemoteCacheManager

public RemoteCacheManager(String servers)

Same as RemoteCacheManager(String, boolean), with start=true.

RemoteCacheManager

public RemoteCacheManager(URL config,
                          boolean start)

Same as RemoteCacheManager(java.util.Properties), but it will try to lookup the config properties in supplied URL.

Parameters:

start - weather or not to start the RemoteCacheManager

Throws:

HotRodClientException - if properties could not be loaded

RemoteCacheManager

public RemoteCacheManager(URL config)

Same as RemoteCacheManager(java.net.URL) and it also starts the cache (start==true).

Parameters:

config -

Method Detail

getCache

public <K,V> RemoteCache<K,V> getCache(String cacheName)

Description copied from interface: CacheContainer

Retrieves a named cache from the system. If the cache has been previously created with the same name, the running cache instance is returned. Otherwise, this method attempts to create the cache first.

In the case of a EmbeddedCacheManager: when creating a new cache, this method will use the configuration passed in to the EmbeddedCacheManager on construction, as a template, and then optionally apply any overrides previously defined for the named cache using the EmbeddedCacheManager.defineConfiguration(String, org.infinispan.config.Configuration) or EmbeddedCacheManager.defineConfiguration(String, String, org.infinispan.config.Configuration) methods, or declared in the configuration file.

NB: Shared caches are supported (and in fact encouraged) but if they are used it's the users responsibility to ensure that at least one but only one caller calls stop() on the cache, and it does so with the awareness that others may be using the cache.

Specified by:

getCache in interface CacheContainer

Parameters:

cacheName - name of cache to retrieve

Returns:

a cache instance identified by cacheName

getCache

public <K,V> RemoteCache<K,V> getCache(String cacheName,
                                       boolean forceReturnValue)

getCache

public <K,V> RemoteCache<K,V> getCache()

Description copied from interface: CacheContainer

Retrieves the default cache associated with this cache container.

As such, this method is always guaranteed to return the default cache.

NB: Shared caches are supported (and in fact encouraged) but if they are used it's the users responsibility to ensure that at least one but only one caller calls stop() on the cache, and it does so with the awareness that others may be using the cache.

Specified by:

getCache in interface CacheContainer

Returns:

the default cache.

getCache

public <K,V> RemoteCache<K,V> getCache(boolean forceReturnValue)

start

public void start()

Specified by:

start in interface Lifecycle

stop

public void stop()

Specified by:

stop in interface Lifecycle

isStarted

public boolean isStarted()