Uses of Class
org.apache.ignite.client.ClientException

Packages that use ClientException

Package	Description
org.apache.ignite	Contains entry-point Ignite & HPC APIs.
org.apache.ignite.client	Contains Ignite Thin Client API classes.
org.apache.ignite.internal.client.thin

Uses of ClientException in org.apache.ignite

Methods in org.apache.ignite that throw ClientException

Modifier and Type	Method	Description
static IgniteClient	Ignition.startClient(ClientConfiguration cfg)	Initializes new instance of IgniteClient.

Uses of ClientException in org.apache.ignite.client

Subclasses of ClientException in org.apache.ignite.client

Modifier and Type	Class	Description
class	ClientAuthenticationException	Indicates user name or password is invalid.
class	ClientAuthorizationException	Indicates user has no permission to perform operation.
class	ClientConnectionException	Indicates all the Ignite servers specified in the client configuration are no longer available.
class	ClientFeatureNotSupportedByServerException	Feature not supported by server exception.
class	ClientReconnectedException	Indicates that previous connection was lost and a new connection established, which can lead to inconsistency of non-atomic operations.

Methods in org.apache.ignite.client that throw ClientException

Modifier and Type	Method	Description
Collection<String>	IgniteClient.cacheNames()	Gets the names of all available caches.
IgniteClientFuture<Collection<String>>	IgniteClient.cacheNamesAsync()	Gets the names of all available caches.
void	ClientCache.clear()	Clears the contents of the cache.
void	ClientCache.clear(K key)	Clears entry with specified key from the cache.
void	ClientCache.clearAll(Set<? extends K> keys)	Clears entries with specified keys from the cache.
IgniteClientFuture<Void>	ClientCache.clearAllAsync(Set<? extends K> keys)	Clears entries with specified keys from the cache asynchronously.
IgniteClientFuture<Void>	ClientCache.clearAsync()	Clears the contents of the cache asynchronously.
IgniteClientFuture<Void>	ClientCache.clearAsync(K key)	Clears entry with specified key from the cache asynchronously.
void	ClientTransaction.commit()	Commits this transaction.
boolean	ClientCache.containsKey(K key)	Determines if the ClientCache contains an entry for the specified key.
IgniteClientFuture<Boolean>	ClientCache.containsKeyAsync(K key)	Determines if the ClientCache contains an entry for the specified key asynchronously.
boolean	ClientCache.containsKeys(Set<? extends K> keys)	Determines if the ClientCache contains entries for the specified keys.
IgniteClientFuture<Boolean>	ClientCache.containsKeysAsync(Set<? extends K> keys)	Determines if the ClientCache contains entries for the specified keys asynchronously.
<K,V> ClientCache<K,V>	IgniteClient.createCache(String name)	Creates a cache with a default configuration.
<K,V> ClientCache<K,V>	IgniteClient.createCache(ClientCacheConfiguration cfg)	Creates a cache with the specified configuration.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.createCacheAsync(String name)	Creates a cache with a default configuration.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.createCacheAsync(ClientCacheConfiguration cfg)	Creates a cache with the specified configuration.
void	IgniteClient.destroyCache(String name)	Destroys the cache with the given name.
IgniteClientFuture<Void>	IgniteClient.destroyCacheAsync(String name)	Destroys the cache with the given name.
boolean	ClientCluster.disableWal(String cacheName)	Disables write-ahead logging for specified cache.
boolean	ClientCluster.enableWal(String cacheName)	Enables write-ahead logging for specified cache.
<T,R> R	ClientCompute.execute(String taskName, T arg)	Executes given task within the cluster group.
<T,R> Future<R>	ClientCompute.executeAsync(String taskName, T arg)	Deprecated. Use ClientCompute.executeAsync2(String, Object) instead.
<T,R> IgniteClientFuture<R>	ClientCompute.executeAsync2(String taskName, T arg)	Executes given task asynchronously within the cluster group.
V	ClientCache.get(K key)	Gets an entry from the cache.
Map<K,V>	ClientCache.getAll(Set<? extends K> keys)	Gets a collection of entries from the ClientCache, returning them as Map of the values associated with the set of keys requested.
IgniteClientFuture<Map<K,V>>	ClientCache.getAllAsync(Set<? extends K> keys)	Gets a collection of entries from the ClientCache, returning them as Map of the values associated with the set of keys requested.
V	ClientCache.getAndPut(K key, V val)	Associates the specified value with the specified key in this cache, returning an existing value if one existed.
IgniteClientFuture<V>	ClientCache.getAndPutAsync(K key, V val)	Associates the specified value with the specified key in this cache, returning an existing value if one existed.
V	ClientCache.getAndPutIfAbsent(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
IgniteClientFuture<V>	ClientCache.getAndPutIfAbsentAsync(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
V	ClientCache.getAndRemove(K key)	Atomically removes the entry for a key only if currently mapped to some value.
IgniteClientFuture<V>	ClientCache.getAndRemoveAsync(K key)	Atomically removes the entry for a key only if currently mapped to some value.
V	ClientCache.getAndReplace(K key, V val)	Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
IgniteClientFuture<V>	ClientCache.getAndReplaceAsync(K key, V val)	Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
ClientCacheConfiguration	ClientCache.getConfiguration()
IgniteClientFuture<ClientCacheConfiguration>	ClientCache.getConfigurationAsync()	Gets the cache configuration asynchronously.
<K,V> ClientCache<K,V>	IgniteClient.getOrCreateCache(String name)	Gets the existing cache or creates a new cache with default configuration if it does not exist.
<K,V> ClientCache<K,V>	IgniteClient.getOrCreateCache(ClientCacheConfiguration cfg)	Gets the existing cache or creates a new cache if it does not exist.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.getOrCreateCacheAsync(String name)	Gets the existing cache or creates a new cache with default configuration if it does not exist.
<K,V> IgniteClientFuture<ClientCache<K,V>>	IgniteClient.getOrCreateCacheAsync(ClientCacheConfiguration cfg)	Gets the existing cache or creates a new cache if it does not exist.
<T> T	ClientCache.invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments)	Invokes an EntryProcessor against the Cache.Entry specified by the provided key.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	ClientCache.invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... args)	Invokes each EntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> IgniteClientFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	ClientCache.invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... args)	Asynchronously invokes each EntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> IgniteClientFuture<T>	ClientCache.invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments)	Asynchronously invokes an EntryProcessor against the Cache.Entry specified by the provided key.
void	ClientCache.put(K key, V val)	Associates the specified value with the specified key in the cache.
void	ClientCache.putAll(Map<? extends K,? extends V> map)	Copies all of the entries from the specified map to the ClientCache.
IgniteClientFuture<Void>	ClientCache.putAllAsync(Map<? extends K,? extends V> map)	Copies all of the entries from the specified map to the ClientCache.
IgniteClientFuture<Void>	ClientCache.putAsync(K key, V val)	Associates the specified value with the specified key in the cache asynchronously.
boolean	ClientCache.putIfAbsent(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
IgniteClientFuture<Boolean>	ClientCache.putIfAbsentAsync(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
boolean	ClientCache.remove(K key)	Removes the mapping for a key from this cache if it is present.
boolean	ClientCache.remove(K key, V oldVal)	Atomically removes the mapping for a key only if currently mapped to the given value.
void	ClientCache.removeAll()	Removes all of the mappings from this cache.
void	ClientCache.removeAll(Set<? extends K> keys)	Removes entries for the specified keys.
IgniteClientFuture<Void>	ClientCache.removeAllAsync()	Removes all of the mappings from this cache.
IgniteClientFuture<Void>	ClientCache.removeAllAsync(Set<? extends K> keys)	Removes entries for the specified keys.
IgniteClientFuture<Boolean>	ClientCache.removeAsync(K key)	Removes the mapping for a key from this cache if it is present.
IgniteClientFuture<Boolean>	ClientCache.removeAsync(K key, V oldVal)	Atomically removes the mapping for a key only if currently mapped to the given value.
boolean	ClientCache.replace(K key, V val)	Atomically replaces the entry for a key only if currently mapped to some value.
boolean	ClientCache.replace(K key, V oldVal, V newVal)	Atomically replaces the entry for a key only if currently mapped to a given value.
IgniteClientFuture<Boolean>	ClientCache.replaceAsync(K key, V val)	Atomically replaces the entry for a key only if currently mapped to some value.
IgniteClientFuture<Boolean>	ClientCache.replaceAsync(K key, V oldVal, V newVal)	Atomically replaces the entry for a key only if currently mapped to a given value.
void	ClientTransaction.rollback()	Rolls back this transaction.
int	ClientCache.size(CachePeekMode... peekModes)	Gets the number of all entries cached across all nodes.
IgniteClientFuture<Integer>	ClientCache.sizeAsync(CachePeekMode... peekModes)	Gets the number of all entries cached across all nodes.
void	ClientCluster.state(ClusterState newState)	Changes current cluster state to given newState cluster state.
ClientTransaction	ClientTransactions.txStart()	Starts a new transaction with the default isolation level, concurrency and timeout.
ClientTransaction	ClientTransactions.txStart(TransactionConcurrency concurrency, TransactionIsolation isolation)	Starts a new transaction with the specified concurrency and isolation.
ClientTransaction	ClientTransactions.txStart(TransactionConcurrency concurrency, TransactionIsolation isolation, long timeout)	Starts a new transaction with the specified isolation, concurrency and timeout.
ClientTransactions	ClientTransactions.withLabel(String lb)	Returns instance of ClientTransactions to mark each new transaction with a specified label.

Uses of ClientException in org.apache.ignite.internal.client.thin

Methods in org.apache.ignite.internal.client.thin that throw ClientException

Modifier and Type	Method	Description
Collection<String>	TcpIgniteClient.cacheNames()	Gets the names of all available caches.
IgniteClientFuture<Collection<String>>	TcpIgniteClient.cacheNamesAsync()	Gets the names of all available caches.
void	TcpClientCache.clear()	Clears the contents of the cache.
void	TcpClientCache.clear(K key)	Clears entry with specified key from the cache.
void	TcpClientCache.clearAll(Set<? extends K> keys)	Clears entries with specified keys from the cache.
IgniteClientFuture<Void>	TcpClientCache.clearAllAsync(Set<? extends K> keys)	Clears entries with specified keys from the cache asynchronously.
IgniteClientFuture<Void>	TcpClientCache.clearAsync()	Clears the contents of the cache asynchronously.
IgniteClientFuture<Void>	TcpClientCache.clearAsync(K key)	Clears entry with specified key from the cache asynchronously.
boolean	TcpClientCache.containsKey(K key)	Determines if the ClientCache contains an entry for the specified key.
IgniteClientFuture<Boolean>	TcpClientCache.containsKeyAsync(K key)	Determines if the ClientCache contains an entry for the specified key asynchronously.
boolean	TcpClientCache.containsKeys(Set<? extends K> keys)	Determines if the ClientCache contains entries for the specified keys.
IgniteClientFuture<Boolean>	TcpClientCache.containsKeysAsync(Set<? extends K> keys)	Determines if the ClientCache contains entries for the specified keys asynchronously.
<K,V> ClientCache<K,V>	TcpIgniteClient.createCache(String name)	Creates a cache with a default configuration.
<K,V> ClientCache<K,V>	TcpIgniteClient.createCache(ClientCacheConfiguration cfg)	Creates a cache with the specified configuration.
<K,V> IgniteClientFuture<ClientCache<K,V>>	TcpIgniteClient.createCacheAsync(String name)	Creates a cache with a default configuration.
<K,V> IgniteClientFuture<ClientCache<K,V>>	TcpIgniteClient.createCacheAsync(ClientCacheConfiguration cfg)	Creates a cache with the specified configuration.
void	TcpIgniteClient.destroyCache(String name)	Destroys the cache with the given name.
IgniteClientFuture<Void>	TcpIgniteClient.destroyCacheAsync(String name)	Destroys the cache with the given name.
boolean	ClientClusterImpl.disableWal(String cacheName)	Disables write-ahead logging for specified cache.
boolean	ClientClusterImpl.enableWal(String cacheName)	Enables write-ahead logging for specified cache.
V	TcpClientCache.get(K key)	Gets an entry from the cache.
Map<K,V>	TcpClientCache.getAll(Set<? extends K> keys)	Gets a collection of entries from the ClientCache, returning them as Map of the values associated with the set of keys requested.
IgniteClientFuture<Map<K,V>>	TcpClientCache.getAllAsync(Set<? extends K> keys)	Gets a collection of entries from the ClientCache, returning them as Map of the values associated with the set of keys requested.
V	TcpClientCache.getAndPut(K key, V val)	Associates the specified value with the specified key in this cache, returning an existing value if one existed.
IgniteClientFuture<V>	TcpClientCache.getAndPutAsync(K key, V val)	Associates the specified value with the specified key in this cache, returning an existing value if one existed.
V	TcpClientCache.getAndPutIfAbsent(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
IgniteClientFuture<V>	TcpClientCache.getAndPutIfAbsentAsync(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
V	TcpClientCache.getAndRemove(K key)	Atomically removes the entry for a key only if currently mapped to some value.
IgniteClientFuture<V>	TcpClientCache.getAndRemoveAsync(K key)	Atomically removes the entry for a key only if currently mapped to some value.
V	TcpClientCache.getAndReplace(K key, V val)	Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
IgniteClientFuture<V>	TcpClientCache.getAndReplaceAsync(K key, V val)	Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
ClientCacheConfiguration	TcpClientCache.getConfiguration()
IgniteClientFuture<ClientCacheConfiguration>	TcpClientCache.getConfigurationAsync()	Gets the cache configuration asynchronously.
<K,V> ClientCache<K,V>	TcpIgniteClient.getOrCreateCache(String name)	Gets the existing cache or creates a new cache with default configuration if it does not exist.
<K,V> ClientCache<K,V>	TcpIgniteClient.getOrCreateCache(ClientCacheConfiguration cfg)	Gets the existing cache or creates a new cache if it does not exist.
<K,V> IgniteClientFuture<ClientCache<K,V>>	TcpIgniteClient.getOrCreateCacheAsync(String name)	Gets the existing cache or creates a new cache with default configuration if it does not exist.
<K,V> IgniteClientFuture<ClientCache<K,V>>	TcpIgniteClient.getOrCreateCacheAsync(ClientCacheConfiguration cfg)	Gets the existing cache or creates a new cache if it does not exist.
<T> T	TcpClientCache.invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments)	Invokes an EntryProcessor against the Cache.Entry specified by the provided key.
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>	TcpClientCache.invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments)	Invokes each EntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> IgniteClientFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>	TcpClientCache.invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments)	Asynchronously invokes each EntryProcessor against the set of Cache.Entrys specified by the set of keys.
<T> IgniteClientFuture<T>	TcpClientCache.invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments)	Asynchronously invokes an EntryProcessor against the Cache.Entry specified by the provided key.
void	TcpClientCache.put(K key, V val)	Associates the specified value with the specified key in the cache.
void	TcpClientCache.putAll(Map<? extends K,? extends V> map)	Copies all of the entries from the specified map to the ClientCache.
IgniteClientFuture<Void>	TcpClientCache.putAllAsync(Map<? extends K,? extends V> map)	Copies all of the entries from the specified map to the ClientCache.
void	TcpClientCache.putAllConflict(Map<? extends K,? extends T3<? extends V,GridCacheVersion,Long>> drMap)	Store DR data.
IgniteClientFuture<Void>	TcpClientCache.putAllConflictAsync(Map<? extends K,T3<? extends V,GridCacheVersion,Long>> drMap)	Store DR data asynchronously.
IgniteClientFuture<Void>	TcpClientCache.putAsync(K key, V val)	Associates the specified value with the specified key in the cache asynchronously.
boolean	TcpClientCache.putIfAbsent(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
IgniteClientFuture<Boolean>	TcpClientCache.putIfAbsentAsync(K key, V val)	Atomically associates the specified key with the given value if it is not already associated with a value.
boolean	TcpClientCache.remove(K key)	Removes the mapping for a key from this cache if it is present.
boolean	TcpClientCache.remove(K key, V oldVal)	Atomically removes the mapping for a key only if currently mapped to the given value.
void	TcpClientCache.removeAll()	Removes all of the mappings from this cache.
void	TcpClientCache.removeAll(Set<? extends K> keys)	Removes entries for the specified keys.
IgniteClientFuture<Void>	TcpClientCache.removeAllAsync()	Removes all of the mappings from this cache.
IgniteClientFuture<Void>	TcpClientCache.removeAllAsync(Set<? extends K> keys)	Removes entries for the specified keys.
void	TcpClientCache.removeAllConflict(Map<? extends K,GridCacheVersion> drMap)	Removes DR data.
IgniteClientFuture<Void>	TcpClientCache.removeAllConflictAsync(Map<? extends K,GridCacheVersion> drMap)	Removes DR data asynchronously.
IgniteClientFuture<Boolean>	TcpClientCache.removeAsync(K key)	Removes the mapping for a key from this cache if it is present.
IgniteClientFuture<Boolean>	TcpClientCache.removeAsync(K key, V oldVal)	Atomically removes the mapping for a key only if currently mapped to the given value.
boolean	TcpClientCache.replace(K key, V val)	Atomically replaces the entry for a key only if currently mapped to some value.
boolean	TcpClientCache.replace(K key, V oldVal, V newVal)	Atomically replaces the entry for a key only if currently mapped to a given value.
IgniteClientFuture<Boolean>	TcpClientCache.replaceAsync(K key, V val)	Atomically replaces the entry for a key only if currently mapped to some value.
IgniteClientFuture<Boolean>	TcpClientCache.replaceAsync(K key, V oldVal, V newVal)	Atomically replaces the entry for a key only if currently mapped to a given value.
int	TcpClientCache.size(CachePeekMode... peekModes)	Gets the number of all entries cached across all nodes.
IgniteClientFuture<Integer>	TcpClientCache.sizeAsync(CachePeekMode... peekModes)	Gets the number of all entries cached across all nodes.
static IgniteClient	TcpIgniteClient.start(ClientConfiguration cfg)	Initializes new instance of IgniteClient.
void	ClientClusterImpl.state(ClusterState newState)	Changes current cluster state to given newState cluster state.
void	ClientClusterImpl.state(ClusterState newState, boolean forceDeactivation)	Changes current cluster state to given newState cluster state.